package gudusoft.gsqlparser.parser;

import gudusoft.gsqlparser.*;

import java.util.ArrayList;

/**
 * Immutable result of a parsing operation.
 *
 * <p>This value object encapsulates all outputs produced by SQL parsing,
 * providing clean separation between parser implementation and result data.
 * Once built, a SqlParseResult instance cannot be modified (immutable).
 *
 * <p><b>Design Pattern:</b> Value Object + Builder
 * <ul>
 *   <li>Immutable: Thread-safe, can be safely shared</li>
 *   <li>Builder: Flexible construction by parser implementations</li>
 *   <li>Clean boundaries: Input/Output separation</li>
 * </ul>
 *
 * <p><b>Contents:</b>
 * <ul>
 *   <li><b>Parse Tree:</b> TStatementList with all parsed statements</li>
 *   <li><b>Tokens:</b> TSourceTokenList with all source tokens</li>
 *   <li><b>Errors:</b> Error code, message, and detailed syntax errors</li>
 *   <li><b>Performance:</b> Timing metrics for each phase</li>
 *   <li><b>State:</b> Lexer and parser instances (for getFlexer() compatibility)</li>
 * </ul>
 *
 * <p><b>Usage Example:</b>
 * <pre>
 * SqlParseResult result = parser.parse(context);
 *
 * // Check for errors
 * if (result.hasErrors()) {
 *     System.err.println(result.getErrorMessage());
 *     return;
 * }
 *
 * // Access parsed statements
 * TStatementList statements = result.getSqlStatements();
 * for (int i = 0; i < statements.size(); i++) {
 *     TCustomSqlStatement stmt = statements.get(i);
 *     // Process statement...
 * }
 * </pre>
 *
 * @see SqlParser
 * @see ParserContext
 * @since 3.2.0.0
 */
public final class SqlParseResult {

    // ========== Parse Results ==========
    private final TSourceTokenList sourceTokenList;
    private final TStatementList sqlStatements;

    public TSourceToken getLastTokenOfStatementBeenValidated() {
        return lastTokenOfStatementBeenValidated;
    }

    private TSourceToken lastTokenOfStatementBeenValidated;


    // ========== Error Information ==========
    private final String errorMessage;
    private final int errorCode;
    private final ArrayList<TSyntaxError> syntaxErrors;

    // ========== Performance Metrics ==========
    private final long tokenizationTimeMs;
    private final long parsingTimeMs;
    private final long semanticAnalysisTimeMs;
    private final long interpreterTimeMs;

    // ========== Vendor-Specific State ==========
    // These are preserved for backward compatibility with getFlexer()
    private final TCustomLexer lexer;
    private final TCustomParser parser;
    private final TCustomParser secondaryParser;  // For Oracle: fplsqlparser

    /**
     * Private constructor - use Builder to create instances.
     */
    private SqlParseResult(Builder builder) {
        // Parse results
        this.sourceTokenList = builder.sourceTokenList;
        this.sqlStatements = builder.sqlStatements;

        // Make defensive copy of statement list to preserve immutability
        // This ensures that if the parser reuses its internal statement list,
        // previous results remain independent and unchanged
//        if (builder.sqlStatements != null) {
//            this.sqlStatements = new TStatementList();
//            for (int i = 0; i < builder.sqlStatements.size(); i++) {
//                this.sqlStatements.add(builder.sqlStatements.get(i));
//            }
//        } else {
//            this.sqlStatements = null;
//        }

        this.lastTokenOfStatementBeenValidated = builder.lastTokenOfStatementBeenValidated;

        // Error information
        this.errorMessage = builder.errorMessage;
        this.errorCode = builder.errorCode;
        this.syntaxErrors = builder.syntaxErrors != null ?
                builder.syntaxErrors : new ArrayList<TSyntaxError>();

        // Performance metrics
        this.tokenizationTimeMs = builder.tokenizationTimeMs;
        this.parsingTimeMs = builder.parsingTimeMs;
        this.semanticAnalysisTimeMs = builder.semanticAnalysisTimeMs;
        this.interpreterTimeMs = builder.interpreterTimeMs;

        // Vendor state
        this.lexer = builder.lexer;
        this.parser = builder.parser;
        this.secondaryParser = builder.secondaryParser;
    }

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

    /**
     * Get the list of source tokens.
     *
     * @return source token list, or null if tokenization failed
     */
    public TSourceTokenList getSourceTokenList() {
        return sourceTokenList;
    }

    /**
     * Get the list of parsed SQL statements.
     *
     * @return statement list, or null if parsing failed
     */
    public TStatementList getSqlStatements() {
        return sqlStatements;
    }

    /**
     * Get the error message if parsing failed.
     *
     * @return error message, or empty string if no error
     */
    public String getErrorMessage() {
        return errorMessage;
    }

    /**
     * Get the error code.
     *
     * @return 0 if successful, non-zero if error occurred
     */
    public int getErrorCode() {
        return errorCode;
    }

    /**
     * Get detailed syntax errors.
     *
     * @return list of syntax errors, empty if no errors
     */
    public ArrayList<TSyntaxError> getSyntaxErrors() {
        return syntaxErrors;
    }

    /**
     * Get tokenization time in milliseconds.
     *
     * @return tokenization time in ms
     */
    public long getTokenizationTimeMs() {
        return tokenizationTimeMs;
    }

    /**
     * Get parsing time in milliseconds.
     *
     * @return parsing time in ms
     */
    public long getParsingTimeMs() {
        return parsingTimeMs;
    }

    /**
     * Get semantic analysis time in milliseconds.
     *
     * @return semantic analysis time in ms
     */
    public long getSemanticAnalysisTimeMs() {
        return semanticAnalysisTimeMs;
    }

    /**
     * Get interpreter time in milliseconds.
     *
     * @return interpreter time in ms
     */
    public long getInterpreterTimeMs() {
        return interpreterTimeMs;
    }

    /**
     * Get total time (all phases combined) in milliseconds.
     *
     * @return total time in ms
     */
    public long getTotalTimeMs() {
        return tokenizationTimeMs + parsingTimeMs + semanticAnalysisTimeMs + interpreterTimeMs;
    }

    /**
     * Get the lexer instance (for backward compatibility).
     *
     * @return the lexer instance
     */
    public TCustomLexer getLexer() {
        return lexer;
    }

    /**
     * Get the parser instance (for backward compatibility).
     *
     * @return the parser instance
     */
    public TCustomParser getParser() {
        return parser;
    }

    /**
     * Get the secondary parser instance (for Oracle PL/SQL parser).
     *
     * @return the secondary parser instance, or null if not applicable
     */
    public TCustomParser getSecondaryParser() {
        return secondaryParser;
    }

    /**
     * Check if parsing resulted in errors.
     *
     * @return true if there were errors, false otherwise
     */
    public boolean hasErrors() {
        return errorCode != 0 || (syntaxErrors != null && !syntaxErrors.isEmpty());
    }

    /**
     * Check if parsing was successful.
     *
     * @return true if no errors, false otherwise
     */
    public boolean isSuccessful() {
        return !hasErrors();
    }

    /**
     * Builder for constructing SqlParseResult instances.
     *
     * <p>Used by SqlParser implementations to build the result object
     * as parsing progresses.
     *
     * <p><b>Example:</b>
     * <pre>
     * SqlParseResult.Builder builder = new SqlParseResult.Builder();
     * builder.sourceTokenList(tokens);
     * builder.sqlStatements(statements);
     * builder.errorCode(0);
     * builder.tokenizationTimeMs(50);
     * builder.parsingTimeMs(120);
     * return builder.build();
     * </pre>
     */
    public static class Builder {
        // Optional fields with defaults
        private TSourceTokenList sourceTokenList = null;
        private TStatementList sqlStatements = null;
        private TSourceToken lastTokenOfStatementBeenValidated;

        private String errorMessage = "";
        private int errorCode = 0;
        private ArrayList<TSyntaxError> syntaxErrors = new ArrayList<>();

        private long tokenizationTimeMs = 0;
        private long parsingTimeMs = 0;
        private long semanticAnalysisTimeMs = 0;
        private long interpreterTimeMs = 0;

        private TCustomLexer lexer = null;
        private TCustomParser parser = null;
        private TCustomParser secondaryParser = null;

        /**
         * Create a builder with default values.
         */
        public Builder() {
            // Default constructor
        }

        /**
         * Set source token list.
         *
         * @param sourceTokenList the source token list
         * @return this builder for method chaining
         */
        public Builder sourceTokenList(TSourceTokenList sourceTokenList) {
            this.sourceTokenList = sourceTokenList;
            return this;
        }

        /**
         * Set SQL statements list.
         *
         * @param sqlStatements the SQL statements list
         * @return this builder for method chaining
         */
        public Builder sqlStatements(TStatementList sqlStatements) {
            this.sqlStatements = sqlStatements;
            return this;
        }


        public Builder lastTokenOfStatementBeenValidated(TSourceToken lastTokenOfStatementBeenValidated) {
            this.lastTokenOfStatementBeenValidated = lastTokenOfStatementBeenValidated;
            return this;
        }

        /**
         * Set error message.
         *
         * @param errorMessage the error message
         * @return this builder for method chaining
         */
        public Builder errorMessage(String errorMessage) {
            this.errorMessage = errorMessage != null ? errorMessage : "";
            return this;
        }

        /**
         * Set error code.
         *
         * @param errorCode the error code (0 = success)
         * @return this builder for method chaining
         */
        public Builder errorCode(int errorCode) {
            this.errorCode = errorCode;
            return this;
        }

        /**
         * Set syntax errors list.
         *
         * @param syntaxErrors the syntax errors list
         * @return this builder for method chaining
         */
        public Builder syntaxErrors(ArrayList<TSyntaxError> syntaxErrors) {
            this.syntaxErrors = syntaxErrors;
            return this;
        }

        /**
         * Add a single syntax error.
         *
         * @param syntaxError the syntax error to add
         * @return this builder for method chaining
         */
        public Builder addSyntaxError(TSyntaxError syntaxError) {
            if (this.syntaxErrors == null) {
                this.syntaxErrors = new ArrayList<>();
            }
            this.syntaxErrors.add(syntaxError);
            return this;
        }

        /**
         * Set tokenization time in milliseconds.
         *
         * @param tokenizationTimeMs tokenization time in ms
         * @return this builder for method chaining
         */
        public Builder tokenizationTimeMs(long tokenizationTimeMs) {
            this.tokenizationTimeMs = tokenizationTimeMs;
            return this;
        }

        /**
         * Set parsing time in milliseconds.
         *
         * @param parsingTimeMs parsing time in ms
         * @return this builder for method chaining
         */
        public Builder parsingTimeMs(long parsingTimeMs) {
            this.parsingTimeMs = parsingTimeMs;
            return this;
        }

        /**
         * Set semantic analysis time in milliseconds.
         *
         * @param semanticAnalysisTimeMs semantic analysis time in ms
         * @return this builder for method chaining
         */
        public Builder semanticAnalysisTimeMs(long semanticAnalysisTimeMs) {
            this.semanticAnalysisTimeMs = semanticAnalysisTimeMs;
            return this;
        }

        /**
         * Set interpreter time in milliseconds.
         *
         * @param interpreterTimeMs interpreter time in ms
         * @return this builder for method chaining
         */
        public Builder interpreterTimeMs(long interpreterTimeMs) {
            this.interpreterTimeMs = interpreterTimeMs;
            return this;
        }

        /**
         * Set lexer instance (for backward compatibility).
         *
         * @param lexer the lexer instance
         * @return this builder for method chaining
         */
        public Builder lexer(TCustomLexer lexer) {
            this.lexer = lexer;
            return this;
        }

        /**
         * Set parser instance (for backward compatibility).
         *
         * @param parser the parser instance
         * @return this builder for method chaining
         */
        public Builder parser(TCustomParser parser) {
            this.parser = parser;
            return this;
        }

        /**
         * Set secondary parser instance (for Oracle PL/SQL parser).
         *
         * @param secondaryParser the secondary parser instance
         * @return this builder for method chaining
         */
        public Builder secondaryParser(TCustomParser secondaryParser) {
            this.secondaryParser = secondaryParser;
            return this;
        }

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

    @Override
    public String toString() {
        return "SqlParseResult{" +
                "errorCode=" + errorCode +
                ", statements=" + (sqlStatements != null ? sqlStatements.size() : 0) +
                ", tokens=" + (sourceTokenList != null ? sourceTokenList.size() : 0) +
                ", errors=" + (syntaxErrors != null ? syntaxErrors.size() : 0) +
                ", totalTimeMs=" + getTotalTimeMs() +
                '}';
    }
}