package gudusoft.gsqlparser.dlineage.util;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.dlineage.dataflow.model.ModelBindingManager;
import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.util.SQLUtil;

/**
 * The names dlineage publishes, version 1: the legacy normal form.
 *
 * <p>Each segment is {@code IdentifierService.normalizeStatic} of the name, upper-cased where the legacy collation
 * classes call the role case-insensitive ({@link SQLUtil#legacyNormalSegment}). A name that shares that string with
 * a different name of the same analysis gets a name of its own ({@code NormalNameCollisions}), except in the
 * normalize-output relabel, which asks for the bare legacy fold ({@link Profile#NORMALIZED_OUTPUT}).
 *
 * <p>This is a compatibility renderer, not identity. Call it only where a name is PUBLISHED:
 * <ul>
 * <li>the normalize-output relabel ({@link Profile#NORMALIZED_OUTPUT});</li>
 * <li>the JSON model's names in normalized mode;</li>
 * <li>result-set display labels;</li>
 * <li>a table's {@code normalizedName}.</li>
 * </ul>
 * Do not use it for equality, lookups, keys or merges: use the name service's keys ({@code CanonKey},
 * {@code QualifiedCanonKey}, {@link DlineageUtil#getTableIdentityKey}, {@link DlineageUtil#lexicalColumnKey}). The one
 * exception is explicit: the compatibility bucket of a name that carries no identity ({@link #tableBucket},
 * {@link #columnBucket}, {@link #columnSegmentBucket}).
 *
 * <p>The strings it gives are the published contract of dlineage output version 1. The name service's stored form
 * (the vendor's own bare name) is another output version, not a fix to this one.
 */
public final class LegacyDlineageWireNamesV1 {

    /** Which names of output version 1 to render. */
    public enum Profile {
        /**
         * The names the analysis publishes. Two different names of the analysis that share a legacy fold get names
         * of their own ({@code NormalNameCollisions}). Given identifiers.
         */
        ANALYSIS,
        /**
         * The normalize-output relabel of finished output ({@code Option.setNormalizeOutput(true)}): the bare legacy
         * fold of every name field it is given, labels included, because output version 1 publishes them that way
         * (PostgreSQL {@code 'abc'} becomes {@code 'ABC'}). Colliding names are already kept apart by id.
         */
        NORMALIZED_OUTPUT
    }

    private LegacyDlineageWireNamesV1() {
    }

    /** The published form of a name of the given role, qualified or not, under the analysis's vendor. */
    public static String name(String name, ESQLDataObjectType objectType) {
        return name(Profile.ANALYSIS, ModelBindingManager.getGlobalVendor(), name, objectType);
    }

    /** The published form of a name field of the given role under the analysis's vendor, in the given profile. */
    public static String name(Profile profile, String name, ESQLDataObjectType objectType) {
        return name(profile, ModelBindingManager.getGlobalVendor(), name, objectType);
    }

    /** The published form of a name of the given role, qualified or not. */
    public static String name(EDbVendor vendor, String name, ESQLDataObjectType objectType) {
        return name(Profile.ANALYSIS, vendor, name, objectType);
    }

    /** The published form of a name field of the given role, in the given profile. */
    public static String name(Profile profile, EDbVendor vendor, String name, ESQLDataObjectType objectType) {
        ModelBindingManager manager = profile == Profile.NORMALIZED_OUTPUT ? ModelBindingManager.get() : null;
        boolean previous = manager != null && manager.useLegacyNormalNames(true);
        try {
            return SQLUtil.getIdentifierNormalName(vendor, name, objectType);
        } finally {
            if (manager != null) {
                manager.useLegacyNormalNames(previous);
            }
        }
    }

    /** The published form of a column name, qualified or not, under the analysis's vendor. */
    public static String columnName(String name) {
        return name(name, ESQLDataObjectType.dotColumn);
    }

    /** The published form of a column name, qualified or not. */
    public static String columnName(EDbVendor vendor, String name) {
        return name(vendor, name, ESQLDataObjectType.dotColumn);
    }

    /**
     * The published form of a column reference's own segment: its column name, or the whole reference where it has
     * none.
     */
    public static String columnName(TObjectName column) {
        if (column == null || column.toString() == null) {
            return null;
        }
        String name = column.getColumnNameOnly();
        return columnName(name == null || "".equals(name.trim()) ? column.toString().trim() : name.trim());
    }

    /** The published form of one column segment: the fold without the qualified-name layout. */
    public static String columnSegment(String name) {
        return columnSegment(ModelBindingManager.getGlobalVendor(), name);
    }

    /** The published form of one column segment: the fold without the qualified-name layout. */
    public static String columnSegment(EDbVendor vendor, String name) {
        return segment(vendor, ESQLDataObjectType.dotColumn, name);
    }

    /** The published form of one name segment of the given role (a database link, a column). */
    public static String segment(EDbVendor vendor, ESQLDataObjectType objectType, String name) {
        return SQLUtil.normalizeIdentifier(vendor, objectType, name);
    }

    /** The published form of a routine name under the analysis's vendor. */
    public static String functionName(String name) {
        return name(name, ESQLDataObjectType.dotFunction);
    }

    /**
     * The compatibility bucket of a table's name that carries no identity: its published form in output version 1,
     * the only evidence a merge has left. A table read back from a serialized document publishes either a SQL
     * spelling or a bare stored name, and nothing says which, so the name service cannot read it; a result set's
     * or a variable's name is a label. Merges group such tables by this bucket, as they always did, and key every
     * table that carries an identity by the name service ({@link PhysicalTableMergeKeys}). Not an identity: two
     * tables of one bucket stay apart wherever an identity tells them apart.
     */
    public static String tableBucket(String qualifiedName) {
        return tableName(qualifiedName);
    }

    /**
     * The compatibility bucket of a column's name that carries no identity (a label, a column read back from a
     * serialized document): its published form in output version 1. See {@link #tableBucket}.
     */
    public static String columnBucket(String name) {
        return columnName(name);
    }

    /** {@link #columnBucket} of one column segment, without the qualified-name layout. */
    public static String columnSegmentBucket(String name) {
        return columnSegment(name);
    }

    /** The published form of a table name. */
    public static String tableName(EDbVendor vendor, String name) {
        return name(vendor, name, ESQLDataObjectType.dotTable);
    }

    /**
     * The published form of a table reference under the analysis's vendor. A database link and a call-shaped name
     * keep their suffix as written ({@code t@link}, {@code f(1)}).
     */
    public static String tableName(String name) {
        if (name == null) {
            return null;
        }
        EDbVendor vendor = ModelBindingManager.getGlobalVendor();
        if (ModelBindingManager.get() != null && ModelBindingManager.get().isDblinkTable(name)) {
            int index = name.lastIndexOf("@");
            return index > 0 ? tableName(vendor, name.substring(0, index)) + name.substring(index) : name;
        }
        if (name.endsWith(")") && name.indexOf("(") != -1) {
            return tableName(vendor, name.substring(0, name.lastIndexOf("("))) + name.substring(name.lastIndexOf("("));
        }
        return tableName(vendor, name);
    }
}