package gudusoft.gsqlparser.sqlenv.parser.sqlflow;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.sqlenv.IdentifierInputForm;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;
import gudusoft.gsqlparser.util.SQLUtil;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * The {@code nameForm} declaration of the sqlflow {@code servers} metadata format (plain and
 * sharded), for a reader that works on the parsed JSON tree itself.
 *
 * <p>A file declares once, at its root, how it writes object names: {@code SQL_LEXICAL}
 * ({@code "Amount"}, the default and what the sqlflow-ingester exporter emits) or
 * {@code CATALOG_STORED} ({@code Amount}, the name the database catalog holds). Every reader
 * of the format reads names as SQL text, so a {@code CATALOG_STORED} tree is rewritten here,
 * once, into the SQL spelling of the same stored names. The spelling rule itself is
 * {@link TSQLEnv#toLexical}; this class only knows which JSON key holds which kind of name.</p>
 *
 * <p>{@code SqlflowSQLEnv} and {@code SqlflowShardedSQLEnv} apply the same rule name by name
 * instead, because their public constructors receive a caller-owned map that must not be
 * modified. See docs/refactor/identifier/README.md, "Catalog inputs and name output".</p>
 */
public final class SqlflowNameForm {

    private static final Map<String, ESQLDataObjectType> ROLE_OF_LIST = new HashMap<String, ESQLDataObjectType>();

    static {
        ROLE_OF_LIST.put("databases", ESQLDataObjectType.dotCatalog);
        ROLE_OF_LIST.put("schemas", ESQLDataObjectType.dotSchema);
        ROLE_OF_LIST.put("tables", ESQLDataObjectType.dotTable);
        ROLE_OF_LIST.put("views", ESQLDataObjectType.dotTable);
        ROLE_OF_LIST.put("columns", ESQLDataObjectType.dotColumn);
        ROLE_OF_LIST.put("packages", ESQLDataObjectType.dotOraclePackage);
        ROLE_OF_LIST.put("procedures", ESQLDataObjectType.dotProcedure);
        ROLE_OF_LIST.put("functions", ESQLDataObjectType.dotFunction);
        ROLE_OF_LIST.put("triggers", ESQLDataObjectType.dotTrigger);
        ROLE_OF_LIST.put("synonyms", ESQLDataObjectType.dotSynonyms);
    }

    private SqlflowNameForm() {
    }

    /**
     * The form a {@code servers} file declares; {@code SQL_LEXICAL} when it declares none.
     *
     * @throws TSQLEnv.InvalidNameFormException for a misspelt value
     */
    public static IdentifierInputForm declared(Map root) {
        return TSQLEnv.parseNameForm(root == null ? null : root.get("nameForm"), IdentifierInputForm.SQL_LEXICAL);
    }

    /**
     * Rewrite a parsed {@code servers} file, in place, so that its names are SQL text. Does
     * nothing unless the file declares {@code CATALOG_STORED}. The declaration is then changed
     * to {@code SQL_LEXICAL}, so a second call cannot encode the names twice.
     *
     * @param defaultVendor the dialect of a server that carries no {@code dbVendor}
     * @return the form the file declared before the call
     */
    public static IdentifierInputForm toLexicalInPlace(EDbVendor defaultVendor, Map root) {
        IdentifierInputForm form = declared(root);
        if (form != IdentifierInputForm.CATALOG_STORED) {
            return form;
        }
        Object servers = root.get("servers");
        if (servers instanceof List) {
            for (Object server : (List) servers) {
                if (!(server instanceof Map)) continue;
                String dbVendor = (String) ((Map) server).get("dbVendor");
                EDbVendor vendor = SQLUtil.isEmpty(dbVendor) ? defaultVendor : EDbVendor.valueOf(dbVendor);
                // The server's own "name" is a connection label, not a database object name.
                walk(vendor, (Map) server, null);
            }
        } else {
            // The bare server object as root, the shape SqlflowSQLEnv is constructed with.
            walk(defaultVendor, root, null);
        }
        root.put("nameForm", IdentifierInputForm.SQL_LEXICAL.name());
        return form;
    }

    /**
     * Rewrite one catalog or schema shard of a sharded export, in place. A shard carries no
     * declaration of its own: the manifest's {@code nameForm} covers all of them.
     *
     * @param role what the shard's own {@code name} is ({@code dotCatalog} or
     *             {@code dotSchema}), or null to leave it alone
     */
    public static void shardToLexicalInPlace(EDbVendor vendor, Map shard, ESQLDataObjectType role,
                                             IdentifierInputForm manifestForm) {
        if (manifestForm == IdentifierInputForm.CATALOG_STORED && shard != null) {
            walk(vendor, shard, role);
        }
    }

    private static void walk(EDbVendor vendor, Map node, ESQLDataObjectType role) {
        if (role != null) {
            rewrite(vendor, node, "name", role);
            if (role == ESQLDataObjectType.dotSynonyms) {
                rewrite(vendor, node, "database", ESQLDataObjectType.dotCatalog);
                rewrite(vendor, node, "schema", ESQLDataObjectType.dotSchema);
                rewrite(vendor, node, "sourceDatabase", ESQLDataObjectType.dotCatalog);
                rewrite(vendor, node, "sourceSchema", ESQLDataObjectType.dotSchema);
                rewrite(vendor, node, "sourceName", ESQLDataObjectType.dotTable);
            }
        }
        for (Object e : node.entrySet()) {
            Map.Entry entry = (Map.Entry) e;
            if (!(entry.getValue() instanceof List)) continue;
            ESQLDataObjectType childRole = ROLE_OF_LIST.get(String.valueOf(entry.getKey()));
            for (Object child : (List) entry.getValue()) {
                if (child instanceof Map) {
                    walk(vendor, (Map) child, childRole);
                }
            }
        }
    }

    private static void rewrite(EDbVendor vendor, Map node, String key, ESQLDataObjectType role) {
        Object value = node.get(key);
        if (value instanceof String) {
            node.put(key, TSQLEnv.toLexical(vendor, role, (String) value, IdentifierInputForm.CATALOG_STORED));
        }
    }
}