package gudusoft.gsqlparser.parser;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.EOBTenantMode;
import gudusoft.gsqlparser.IMetaDatabase;
import gudusoft.gsqlparser.ISQLStatementHandle;
import gudusoft.gsqlparser.ITokenHandle;
import gudusoft.gsqlparser.ITokenListHandle;
import gudusoft.gsqlparser.compiler.TFrame;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;
import gudusoft.gsqlparser.stmt.teradata.utilities.TeradataUtilityType;

import java.io.InputStream;
import java.util.Stack;

/**
 * Immutable context carrying all parser inputs and settings.
 *
 * <p>This value object encapsulates all inputs required for SQL parsing,
 * providing clean separation between input configuration and parser implementation.
 * Once built, a ParserContext instance cannot be modified (immutable).
 *
 * <p><b>Design Pattern:</b> Value Object + Builder
 * <ul>
 *   <li>Immutable: Thread-safe, no defensive copying needed</li>
 *   <li>Builder: Flexible construction with optional parameters</li>
 *   <li>Clean boundaries: Input/Output separation</li>
 * </ul>
 *
 * <p><b>Usage Example:</b>
 * <pre>
 * ParserContext context = new ParserContext.Builder(EDbVendor.dbvoracle)
 *     .sqlText("SELECT * FROM employees WHERE salary > 50000")
 *     .enablePartialParsing(true)
 *     .metaDatabase(myMetaDatabase)
 *     .build();
 * </pre>
 *
 * @see SqlParser
 * @see SqlParseResult
 * @since 3.2.0.0
 */
public final class ParserContext {

    // ========== Input Source ==========
    private final EDbVendor vendor;
    private final String sqlText;
    private final String sqlFilename;
    private final InputStream sqlInputStream;
    private final String sqlCharset;

    // ========== Parser Options ==========
    private final boolean enablePartialParsing;
    private final boolean singlePLBlock;
    private final boolean onlyNeedRawParseTree;
    private final boolean enableMssqlColonBindVariables;
    private final TeradataUtilityType teradataUtilityType;

    // ========== OceanBase-Specific Options ==========
    /**
     * Tenant compatibility mode for OceanBase. Mirrors the value set on
     * {@link gudusoft.gsqlparser.TGSqlParser#setOBTenantMode}. Always
     * non-null; defaults to {@link EOBTenantMode#MYSQL} for non-OceanBase
     * vendors and for OceanBase parsers that did not explicitly set a mode.
     * Read by {@code OceanBaseSqlParser} to choose between MySQL and Oracle
     * delegate parsers in Phase 1 and between forked grammar instances in
     * Phase 2/3.
     */
    private final EOBTenantMode oceanBaseTenantMode;

    // ========== Callbacks and Hooks ==========
    private final ISQLStatementHandle sqlStatementHandle;
    private final ITokenHandle tokenHandle;
    private final ITokenListHandle tokenListHandle;

    // ========== Metadata and Environment ==========
    private final IMetaDatabase metaDatabase;
    private final TSQLEnv sqlEnv;

    // ========== Diagnostic Settings ==========
    private final boolean dumpResolverLog;
    private final boolean enableTimeLogging;

    // ========== State (for special cases) ==========
    private final Stack<TFrame> frameStack;

    // ========== Parser Reference (for backfilling) ==========
    /**
     * Reference to TGSqlParser facade for backfilling metadata.
     * This allows parsed statements to access parser's vendor and other properties.
     */
    private final Object gsqlparser;  // Object type to avoid circular dependency

    /**
     * Private constructor - use Builder to create instances.
     */
    private ParserContext(Builder builder) {
        // Input source
        this.vendor = builder.vendor;
        this.sqlText = builder.sqlText;
        this.sqlFilename = builder.sqlFilename;
        this.sqlInputStream = builder.sqlInputStream;
        this.sqlCharset = builder.sqlCharset;

        // Parser options
        this.enablePartialParsing = builder.enablePartialParsing;
        this.singlePLBlock = builder.singlePLBlock;
        this.onlyNeedRawParseTree = builder.onlyNeedRawParseTree;
        this.enableMssqlColonBindVariables = builder.enableMssqlColonBindVariables;
        this.teradataUtilityType = builder.teradataUtilityType;
        this.oceanBaseTenantMode = builder.oceanBaseTenantMode != null
                ? builder.oceanBaseTenantMode : EOBTenantMode.MYSQL;

        // Callbacks
        this.sqlStatementHandle = builder.sqlStatementHandle;
        this.tokenHandle = builder.tokenHandle;
        this.tokenListHandle = builder.tokenListHandle;

        // Metadata
        this.metaDatabase = builder.metaDatabase;
        this.sqlEnv = builder.sqlEnv;

        // Diagnostics
        this.dumpResolverLog = builder.dumpResolverLog;
        this.enableTimeLogging = builder.enableTimeLogging;

        // State
        this.frameStack = builder.frameStack;

        // Parser reference
        this.gsqlparser = builder.gsqlparser;
    }

    // ========== Getters (Read-only access) ==========

    public EDbVendor getVendor() {
        return vendor;
    }

    public String getSqlText() {
        return sqlText;
    }

    public String getSqlFilename() {
        return sqlFilename;
    }

    public InputStream getSqlInputStream() {
        return sqlInputStream;
    }

    public String getSqlCharset() {
        return sqlCharset;
    }

    public boolean isEnablePartialParsing() {
        return enablePartialParsing;
    }

    public boolean isSinglePLBlock() {
        return singlePLBlock;
    }

    public boolean isOnlyNeedRawParseTree() {
        return onlyNeedRawParseTree;
    }

    /**
     * Whether the SQL Server compatibility extension for colon-prefixed bind
     * variables is enabled.
     *
     * @return {@code true} when {@code :name}, {@code :1}, and {@code :@name}
     *         are recognized as bind variables; defaults to {@code false}
     */
    public boolean isMssqlColonBindVariablesEnabled() {
        return enableMssqlColonBindVariables;
    }

    public TeradataUtilityType getTeradataUtilityType() {
        return teradataUtilityType;
    }

    /**
     * Get the OceanBase tenant compatibility mode mirrored from the owning
     * {@link gudusoft.gsqlparser.TGSqlParser}. Always non-null. Meaningful
     * only when {@link #getVendor()} is {@code dbvoceanbase}; otherwise
     * defaults to {@link EOBTenantMode#MYSQL} and is ignored by other
     * vendor parsers.
     *
     * @return the OceanBase tenant mode (never null)
     * @since 4.0.1.4
     */
    public EOBTenantMode getOceanBaseTenantMode() {
        return oceanBaseTenantMode;
    }

    public ISQLStatementHandle getSqlStatementHandle() {
        return sqlStatementHandle;
    }

    public ITokenHandle getTokenHandle() {
        return tokenHandle;
    }

    public ITokenListHandle getTokenListHandle() {
        return tokenListHandle;
    }

    public IMetaDatabase getMetaDatabase() {
        return metaDatabase;
    }

    public TSQLEnv getSqlEnv() {
        return sqlEnv;
    }

    public boolean isDumpResolverLog() {
        return dumpResolverLog;
    }

    public boolean isEnableTimeLogging() {
        return enableTimeLogging;
    }

    public Stack<TFrame> getFrameStack() {
        return frameStack;
    }

    /**
     * Get reference to TGSqlParser facade for backfilling statement metadata.
     * @return TGSqlParser instance or null if not set
     */
    public Object getGsqlparser() {
        return gsqlparser;
    }

    /**
     * Builder for constructing ParserContext instances.
     *
     * <p>The Builder pattern provides:
     * <ul>
     *   <li>Flexible construction with optional parameters</li>
     *   <li>Readable, fluent API</li>
     *   <li>Default values for optional parameters</li>
     *   <li>Immutability of final ParserContext object</li>
     * </ul>
     *
     * <p><b>Example:</b>
     * <pre>
     * ParserContext ctx = new ParserContext.Builder(EDbVendor.dbvoracle)
     *     .sqlText("SELECT * FROM dual")
     *     .enablePartialParsing(true)
     *     .metaDatabase(myMetaDb)
     *     .build();
     * </pre>
     */
    public static class Builder {
        // Required parameters
        private final EDbVendor vendor;

        // Optional parameters with defaults
        private String sqlText = null;
        private String sqlFilename = "";
        private InputStream sqlInputStream = null;
        private String sqlCharset = null;

        private boolean enablePartialParsing = true;
        private boolean singlePLBlock = false;
        private boolean onlyNeedRawParseTree = false;
        private boolean enableMssqlColonBindVariables = false;
        private TeradataUtilityType teradataUtilityType = null;
        private EOBTenantMode oceanBaseTenantMode = EOBTenantMode.MYSQL;

        private ISQLStatementHandle sqlStatementHandle = null;
        private ITokenHandle tokenHandle = null;
        private ITokenListHandle tokenListHandle = null;

        private IMetaDatabase metaDatabase = null;
        private TSQLEnv sqlEnv = null;

        private boolean dumpResolverLog = false;
        private boolean enableTimeLogging = false;

        private Stack<TFrame> frameStack = null;

        private Object gsqlparser = null;

        /**
         * Create a builder with required vendor parameter.
         *
         * @param vendor the database vendor (required)
         */
        public Builder(EDbVendor vendor) {
            if (vendor == null) {
                throw new IllegalArgumentException("vendor cannot be null");
            }
            this.vendor = vendor;
        }

        /**
         * Set SQL text to parse.
         *
         * @param sqlText the SQL text
         * @return this builder for method chaining
         */
        public Builder sqlText(String sqlText) {
            this.sqlText = sqlText != null ? sqlText : "";
            return this;
        }

        /**
         * Set SQL filename to read from.
         *
         * @param sqlFilename the SQL filename
         * @return this builder for method chaining
         */
        public Builder sqlFilename(String sqlFilename) {
            this.sqlFilename = sqlFilename != null ? sqlFilename : "";
            return this;
        }

        /**
         * Set SQL input stream to read from.
         *
         * @param sqlInputStream the SQL input stream
         * @return this builder for method chaining
         */
        public Builder sqlInputStream(InputStream sqlInputStream) {
            this.sqlInputStream = sqlInputStream;
            return this;
        }

        /**
         * Set SQL character set for file reading.
         *
         * @param sqlCharset the character set name
         * @return this builder for method chaining
         */
        public Builder sqlCharset(String sqlCharset) {
            this.sqlCharset = sqlCharset;
            return this;
        }

        /**
         * Enable/disable partial parsing.
         *
         * @param enablePartialParsing true to enable partial parsing
         * @return this builder for method chaining
         */
        public Builder enablePartialParsing(boolean enablePartialParsing) {
            this.enablePartialParsing = enablePartialParsing;
            return this;
        }

        /**
         * Set single PL block mode.
         *
         * @param singlePLBlock true for single PL block
         * @return this builder for method chaining
         */
        public Builder singlePLBlock(boolean singlePLBlock) {
            this.singlePLBlock = singlePLBlock;
            return this;
        }

        /**
         * Set if only raw parse tree is needed.
         *
         * @param onlyNeedRawParseTree true if only raw parse tree needed
         * @return this builder for method chaining
         */
        public Builder onlyNeedRawParseTree(boolean onlyNeedRawParseTree) {
            this.onlyNeedRawParseTree = onlyNeedRawParseTree;
            return this;
        }

        /**
         * Enable or disable the SQL Server compatibility extension for
         * colon-prefixed bind variables. The default is {@code false}.
         *
         * @param enabled {@code true} to recognize {@code :name}, {@code :1},
         *                and {@code :@name} as bind variables
         * @return this builder for method chaining
         */
        public Builder enableMssqlColonBindVariables(boolean enabled) {
            this.enableMssqlColonBindVariables = enabled;
            return this;
        }

        /**
         * Set Teradata utility type.
         *
         * @param teradataUtilityType the Teradata utility type
         * @return this builder for method chaining
         */
        public Builder teradataUtilityType(TeradataUtilityType teradataUtilityType) {
            this.teradataUtilityType = teradataUtilityType;
            return this;
        }

        /**
         * Set the OceanBase tenant compatibility mode. Mirrors the value set
         * via {@link gudusoft.gsqlparser.TGSqlParser#setOBTenantMode}. Null is
         * coerced to {@link EOBTenantMode#MYSQL} on build.
         *
         * @param oceanBaseTenantMode the OB tenant mode
         * @return this builder for method chaining
         * @since 4.0.1.4
         */
        public Builder oceanBaseTenantMode(EOBTenantMode oceanBaseTenantMode) {
            this.oceanBaseTenantMode = oceanBaseTenantMode;
            return this;
        }

        /**
         * Set SQL statement handle callback.
         *
         * @param sqlStatementHandle the statement handle callback
         * @return this builder for method chaining
         */
        public Builder sqlStatementHandle(ISQLStatementHandle sqlStatementHandle) {
            this.sqlStatementHandle = sqlStatementHandle;
            return this;
        }

        /**
         * Set token handle callback.
         *
         * @param tokenHandle the token handle callback
         * @return this builder for method chaining
         */
        public Builder tokenHandle(ITokenHandle tokenHandle) {
            this.tokenHandle = tokenHandle;
            return this;
        }

        /**
         * Set token list handle callback.
         *
         * @param tokenListHandle the token list handle callback
         * @return this builder for method chaining
         */
        public Builder tokenListHandle(ITokenListHandle tokenListHandle) {
            this.tokenListHandle = tokenListHandle;
            return this;
        }

        /**
         * Set metadata database for column/table resolution.
         *
         * @param metaDatabase the metadata database
         * @return this builder for method chaining
         */
        public Builder metaDatabase(IMetaDatabase metaDatabase) {
            this.metaDatabase = metaDatabase;
            return this;
        }

        /**
         * Set SQL environment.
         *
         * @param sqlEnv the SQL environment
         * @return this builder for method chaining
         */
        public Builder sqlEnv(TSQLEnv sqlEnv) {
            this.sqlEnv = sqlEnv;
            return this;
        }

        /**
         * Enable/disable resolver log dumping.
         *
         * @param dumpResolverLog true to dump resolver log
         * @return this builder for method chaining
         */
        public Builder dumpResolverLog(boolean dumpResolverLog) {
            this.dumpResolverLog = dumpResolverLog;
            return this;
        }

        /**
         * Enable/disable time logging.
         *
         * @param enableTimeLogging true to enable time logging
         * @return this builder for method chaining
         */
        public Builder enableTimeLogging(boolean enableTimeLogging) {
            this.enableTimeLogging = enableTimeLogging;
            return this;
        }

        /**
         * Set frame stack for compiler context.
         *
         * @param frameStack the frame stack
         * @return this builder for method chaining
         */
        public Builder frameStack(Stack<TFrame> frameStack) {
            this.frameStack = frameStack;
            return this;
        }

        /**
         * Set reference to TGSqlParser facade for backfilling metadata.
         * @param gsqlparser TGSqlParser instance
         * @return this builder
         */
        public Builder gsqlparser(Object gsqlparser) {
            this.gsqlparser = gsqlparser;
            return this;
        }

        /**
         * Build the immutable ParserContext.
         *
         * @return a new immutable ParserContext instance
         */
        public ParserContext build() {
            return new ParserContext(this);
        }
    }

    @Override
    public String toString() {
        return "ParserContext{" +
                "vendor=" + vendor +
                ", sqlText=" + (sqlText != null && sqlText.length() > 50 ?
                    sqlText.substring(0, 50) + "..." : sqlText) +
                ", sqlFilename='" + sqlFilename + '\'' +
                ", hasInputStream=" + (sqlInputStream != null) +
                '}';
    }
}