package gudusoft.gsqlparser.pp.para;

import gudusoft.gsqlparser.pp.para.styleenums.TAlignOption;
import gudusoft.gsqlparser.pp.para.styleenums.TAlignStyle;
import gudusoft.gsqlparser.pp.para.styleenums.TCaseOption;
import gudusoft.gsqlparser.pp.para.styleenums.TCompactMode;
import gudusoft.gsqlparser.pp.para.styleenums.TEmptyLinesOption;
import gudusoft.gsqlparser.pp.para.styleenums.TLinefeedsCommaOption;

/**
 * Mutable configuration for the SQL pretty-printer.
 *
 * <p>Create an instance with {@link GFmtOptFactory}, finish configuring it,
 * and pass it to the formatter. Do not modify an instance while formatting is
 * in progress. The formatter uses {@link #sessionId} to associate processors
 * and mediators with this option set.</p>
 *
 * <p>Every public field is documented with its default and its interaction
 * with related options. Fields in the "Lifecycle and advanced controls"
 * category are public for compatibility but are not ordinary presentation
 * settings.</p>
 *
 * @author zhoujun
 */
public class GFmtOpt
{

        /**
         * Identifies the formatting session used by formatter, processor, and
         * mediator caches. Use a unique id for independently configured concurrent
         * calls; the id is not rendered in the output.
         *
         * <p><b>Category:</b> Lifecycle and advanced controls</p>
         * <p><b>Default:</b> Supplied to the constructor.</p>
         */
        public final String sessionId;

        /**
         * Enables the low-level source-token mutation operations that implement
         * formatting. Setting this to {@code false} makes token add/remove helpers
         * ignore requests and therefore disables most formatting; it is intended
         * for diagnostics, not as a preserve-layout mode.
         *
         * <p><b>Category:</b> Lifecycle and advanced controls</p>
         * <p><b>Default:</b> {@code true}.</p>
         */
        public boolean opearateSourceToken = true;

        /**
         * Chooses stacked or wrapped layout for SELECT result columns and is also
         * reused by GROUP BY and ORDER BY lists. Stacked layout permits line breaks
         * according to {@link #selectColumnlistComma}; wrapped layout keeps items on
         * the current line. Alias alignment is applied only to stacked lists.
         *
         * <p><b>Category:</b> SELECT list and query clauses</p>
         * <p><b>Default:</b> {@link TAlignStyle#AsStacked}.</p>
         */
        public TAlignStyle selectColumnlistStyle = TAlignStyle.AsStacked;

        /**
         * Chooses whether a comma ends the previous line or begins the next line in
         * stacked SELECT, GROUP BY, and ORDER BY lists. The setting has no line-break
         * effect when {@link #selectColumnlistStyle} is wrapped.
         *
         * <p><b>Category:</b> SELECT list and query clauses</p>
         * <p><b>Default:</b> {@link TLinefeedsCommaOption#LfAfterComma}.</p>
         */
        public TLinefeedsCommaOption selectColumnlistComma = TLinefeedsCommaOption.LfAfterComma;

        /**
         * Places the first SELECT item on a line after SELECT. The same switch also
         * places the first GROUP BY and ORDER BY item, and the HAVING expression,
         * after their clause keywords; subsequent item breaks are controlled by the
         * list style and comma option.
         *
         * <p><b>Category:</b> SELECT list and query clauses</p>
         * <p><b>Default:</b> {@code false}.</p>
         */
        public boolean selectItemInNewLine = false;

        /**
         * Pads stacked SELECT expressions so their explicit or implicit aliases
         * begin in the same column. It is ignored for wrapped lists and may be
         * skipped for exceptionally wide lists to avoid excessive padding.
         *
         * <p><b>Category:</b> SELECT list and query clauses</p>
         * <p><b>Default:</b> {@code true}.</p>
         */
        public boolean alignAliasInSelectList = true;

        /**
         * Adds a synthetic DISTINCT result-column node to the parsed SELECT list so
         * it participates in stacking and comma-layout calculations. This mutates
         * the statement's result-column list for formatting, although the rendered
         * SQL semantics are unchanged.
         *
         * <p><b>Category:</b> SELECT list and query clauses</p>
         * <p><b>Default:</b> {@code false}.</p>
         */
        public boolean treatDistinctAsVirtualColumn = false;

        /**
         * Chooses stacked or wrapped layout for comma-separated table sources in a
         * FROM clause. JOIN clauses have their own newline and alignment controls.
         *
         * <p><b>Category:</b> FROM, JOIN, and WHERE</p>
         * <p><b>Default:</b> {@link TAlignStyle#AsStacked}.</p>
         */
        public TAlignStyle selectFromclauseStyle = TAlignStyle.AsStacked;

        /**
         * Positions commas for stacked comma-separated FROM items. It is effective
         * only when {@link #selectFromclauseStyle} is stacked.
         *
         * <p><b>Category:</b> FROM, JOIN, and WHERE</p>
         * <p><b>Default:</b> {@link TLinefeedsCommaOption#LfAfterComma}.</p>
         */
        public TLinefeedsCommaOption selectFromclauseComma = TLinefeedsCommaOption.LfAfterComma;

        /**
         * Places the first table source on a new indented line after FROM (and the
         * corresponding INTO table source where that clause shares this processor).
         * When false, one space separates the clause keyword and first source.
         *
         * <p><b>Category:</b> FROM, JOIN, and WHERE</p>
         * <p><b>Default:</b> {@code false}.</p>
         */
        public boolean fromClauseInNewLine = false;

        /**
         * Places the ON condition of a JOIN on a separate line. JOIN keywords are
         * always normalized onto their own lines by the JOIN processor; this switch
         * controls the additional break before ON.
         *
         * <p><b>Category:</b> FROM, JOIN, and WHERE</p>
         * <p><b>Default:</b> {@code true}.</p>
         */
        public boolean selectFromclauseJoinOnInNewline = true;

        /**
         * Aligns the beginning of JOIN phrases with the FROM keyword rather than
         * with the first table source. It does not control whether ON starts a new
         * line; use {@link #selectFromclauseJoinOnInNewline} for that.
         *
         * <p><b>Category:</b> FROM, JOIN, and WHERE</p>
         * <p><b>Default:</b> {@code false}.</p>
         */
        public boolean alignJoinWithFromKeyword = false;

        /**
         * Aligns leading AND and OR operators under the WHERE keyword. When false,
         * boolean continuations use the expression formatter's normal indentation.
         *
         * <p><b>Category:</b> FROM, JOIN, and WHERE</p>
         * <p><b>Default:</b> {@code false}.</p>
         */
        public boolean andOrUnderWhere = false;

        /**
         * Chooses stacked or wrapped layout for the target-column list of INSERT.
         * Comma placement comes from {@link #defaultCommaOption} rather than the
         * SELECT-specific comma option.
         *
         * <p><b>Category:</b> INSERT and general lists</p>
         * <p><b>Default:</b> {@link TAlignStyle#AsStacked}.</p>
         */
        public TAlignStyle insertColumnlistStyle = TAlignStyle.AsStacked;

        /**
         * Chooses stacked or wrapped layout for each INSERT VALUES list. Comma
         * placement comes from {@link #defaultCommaOption}.
         *
         * <p><b>Category:</b> INSERT and general lists</p>
         * <p><b>Default:</b> {@link TAlignStyle#AsStacked}.</p>
         */
        public TAlignStyle insertValuelistStyle = TAlignStyle.AsStacked;

        /**
         * Places the opening parenthesis of a CREATE TABLE column list on a new line
         * and indents it by {@link #indentLen}. If list items are also placed on new
         * lines, they receive one additional indentation level.
         *
         * <p><b>Category:</b> CREATE TABLE</p>
         * <p><b>Default:</b> {@code false}.</p>
         */
        public boolean beStyleCreatetableLeftBEOnNewline = false;

        /**
         * Places the closing parenthesis of a CREATE TABLE column list on its own
         * line. Its indentation accounts for whether the opening parenthesis was
         * also moved to a new line.
         *
         * <p><b>Category:</b> CREATE TABLE</p>
         * <p><b>Default:</b> {@code false}.</p>
         */
        public boolean beStyleCreatetableRightBEOnNewline = false;

        /**
         * Places the first CREATE TABLE column or constraint on a new line after the
         * opening parenthesis. Remaining items follow {@link #defaultAligntype} and
         * {@link #defaultCommaOption}.
         *
         * <p><b>Category:</b> CREATE TABLE</p>
         * <p><b>Default:</b> {@code false}.</p>
         */
        public boolean createtableListitemInNewLine = false;

        /**
         * Left- or right-aligns CREATE TABLE column names within the widest column-
         * name width. It is applied only when {@link #defaultAligntype} is stacked.
         *
         * <p><b>Category:</b> CREATE TABLE</p>
         * <p><b>Default:</b> {@link TAlignOption#AloLeft}.</p>
         */
        public TAlignOption createtableFieldlistAlignOption = TAlignOption.AloLeft;

        /**
         * Provides comma placement for formatter lists without a dedicated comma
         * setting, including INSERT columns/values, UPDATE SET items, and CREATE
         * TABLE columns and constraints.
         *
         * <p><b>Category:</b> INSERT and general lists</p>
         * <p><b>Default:</b> {@link TLinefeedsCommaOption#LfAfterComma}.</p>
         */
        public TLinefeedsCommaOption defaultCommaOption = TLinefeedsCommaOption.LfAfterComma;

        /**
         * Provides stacked or wrapped layout for lists without a dedicated style,
         * notably UPDATE SET and CREATE TABLE lists. INSERT has separate style fields
         * but still uses {@link #defaultCommaOption} for commas.
         *
         * <p><b>Category:</b> INSERT and general lists</p>
         * <p><b>Default:</b> {@link TAlignStyle#AsStacked}.</p>
         */
        public TAlignStyle defaultAligntype = TAlignStyle.AsStacked;

        /**
         * Sets the general indentation increment, in columns, used by nested clauses,
         * expressions, CTE bodies, parameters, and many statement processors. More
         * specialized indentation options add to, rather than replace, this value.
         *
         * <p><b>Category:</b> Indentation and procedural blocks</p>
         * <p><b>Default:</b> {@code 2}.</p>
         */
        public Integer indentLen = 2;

        /**
         * Enables the final tab-alignment pass. The formatter first computes spaces,
         * then pads each indented line to a multiple of {@link #tabSize}; this option
         * does not replace all indentation characters with literal tab characters.
         *
         * <p><b>Category:</b> Indentation and procedural blocks</p>
         * <p><b>Default:</b> {@code false}.</p>
         */
        public Boolean useTab = false;

        /**
         * Defines the tab-stop width used by the final tab-alignment pass when
         * {@link #useTab} is enabled. Use a positive value.
         *
         * <p><b>Category:</b> Indentation and procedural blocks</p>
         * <p><b>Default:</b> {@code 2}.</p>
         */
        public Integer tabSize = 2;

        /**
         * Reserved compatibility setting for stored-routine body indentation. The
         * active formatter currently does not read this field; use
         * {@link #beStyleBlockIndentSize} and {@link #indentLen} for effective body
         * indentation.
         *
         * <p><b>Category:</b> Indentation and procedural blocks</p>
         * <p><b>Default:</b> {@code 2}; currently has no effect.</p>
         */
        public Integer beStyleFunctionBodyIndent = 2;

        /**
         * Places a procedural BEGIN token on a new line. This is used by PL/SQL-like
         * blocks and by SQL Server BEGIN/END block formatting, with vendor-specific
         * paths applying the related indentation settings.
         *
         * <p><b>Category:</b> Indentation and procedural blocks</p>
         * <p><b>Default:</b> {@code true}.</p>
         */
        public Boolean beStyleBlockLeftBEOnNewline = true;

        /**
         * Adds columns to the containing statement's indentation for a BEGIN token
         * moved to a new line. It is meaningful when
         * {@link #beStyleBlockLeftBEOnNewline} is true.
         *
         * <p><b>Category:</b> Indentation and procedural blocks</p>
         * <p><b>Default:</b> {@code 2}.</p>
         */
        public Integer beStyleBlockLeftBEIndentSize = 2;

        /**
         * Controls END indentation for block paths where BEGIN remains on the current
         * line. When BEGIN is moved, those paths align END using the BEGIN indent
         * instead, so this value may be ignored.
         *
         * <p><b>Category:</b> Indentation and procedural blocks</p>
         * <p><b>Default:</b> {@code 2}.</p>
         */
        public Integer beStyleBlockRightBEIndentSize = 2;

        /**
         * Adds indentation to statements inside BEGIN/END blocks and to returned
         * query bodies in supported CREATE FUNCTION and CREATE VIEW forms. It is
         * measured relative to the enclosing block marker.
         *
         * <p><b>Category:</b> Indentation and procedural blocks</p>
         * <p><b>Default:</b> {@code 2}.</p>
         */
        public Integer beStyleBlockIndentSize = 2;

        /**
         * Adds indentation to a single statement controlled by IF or ELSE when the
         * body is not represented as a BEGIN/END block. Block bodies instead use the
         * block indentation options.
         *
         * <p><b>Category:</b> Indentation and procedural blocks</p>
         * <p><b>Default:</b> {@code 2}.</p>
         */
        public Integer beStyleIfElseSingleStmtIndentSize = 2;

        /**
         * Keeps each WHEN condition and its THEN keyword on one line when true. When
         * false, THEN starts a new line and its indentation additionally uses
         * {@link #indentCaseThen}.
         *
         * <p><b>Category:</b> CASE expressions</p>
         * <p><b>Default:</b> {@code false}.</p>
         */
        public Boolean caseWhenThenInSameLine = false;

        /**
         * Indents WHEN, ELSE, and END relative to the CASE keyword. The value is an
         * absolute number of columns added at that CASE nesting level.
         *
         * <p><b>Category:</b> CASE expressions</p>
         * <p><b>Default:</b> {@code 2}.</p>
         */
        public Integer indentCaseFromSwitch = 2;

        /**
         * Adds indentation to a line-broken THEN relative to its WHEN indentation.
         * It is ignored when {@link #caseWhenThenInSameLine} is true.
         *
         * <p><b>Category:</b> CASE expressions</p>
         * <p><b>Default:</b> {@code 0}.</p>
         */
        public Integer indentCaseThen = 0;

        /**
         * Left- or right-aligns multiword and single-word query clause labels such as
         * SELECT, FROM, WHERE, GROUP BY, HAVING, and ORDER BY within their shared
         * keyword width.
         *
         * <p><b>Category:</b> Keyword alignment and capitalization</p>
         * <p><b>Default:</b> {@link TAlignOption#AloLeft}.</p>
         */
        public TAlignOption selectKeywordsAlignOption = TAlignOption.AloLeft;

        /**
         * Converts SQL keyword tokens to the selected case. Datatypes and recognized
         * function names use their dedicated case settings instead.
         *
         * <p><b>Category:</b> Keyword alignment and capitalization</p>
         * <p><b>Default:</b> {@link TCaseOption#CoUppercase}.</p>
         */
        public TCaseOption caseKeywords = TCaseOption.CoUppercase;

        /**
         * Converts unquoted identifier tokens that are not recognized as datatypes
         * or function names. Table names, column names, table aliases and column
         * aliases use {@link #caseTableName}, {@link #caseColumnName},
         * {@link #caseTableAlias} and {@link #caseColumnAlias} instead when those
         * are set. Changing case can change semantics in case-sensitive
         * databases, so preserve case unless that transformation is intentional.
         *
         * <p><b>Category:</b> Keyword alignment and capitalization</p>
         * <p><b>Default:</b> {@link TCaseOption#CoNoChange}.</p>
         */
        public TCaseOption caseIdentifier = TCaseOption.CoNoChange;

        /**
         * Converts unquoted table and view names, including a table name that
         * qualifies a column ({@code orders.id}). CTE names are not tables here:
         * they follow {@link #caseIdentifier}, as do schema and database names.
         * What a name is comes from name resolution ({@code TSQLResolver2}), which
         * runs only when the SQL parses; for SQL that does not, and when this is
         * null, table names follow {@link #caseIdentifier}.
         *
         * <p>This setting and {@link #caseColumnName}, {@link #caseTableAlias} and
         * {@link #caseColumnAlias} never change delimited names ({@code "x"},
         * {@code [x]}, {@code `x`}). Where resolution does not report every use
         * of a table name or table alias (SQL Server's
         * {@code UPDATE o ... FROM orders o}, a view created and then used in one
         * script) and following them would give one name two cases, all four are
         * off for the whole input, which then uses {@link #caseIdentifier}.
         *
         * <p><b>Category:</b> Keyword alignment and capitalization</p>
         * <p><b>Default:</b> {@code null} (follows {@link #caseIdentifier}).</p>
         */
        public TCaseOption caseTableName = null;

        /**
         * Converts the column name of unquoted column references
         * ({@code order_id} in {@code o.order_id}), as name resolution finds
         * them. For SQL that does not parse, and when this is null, column names
         * follow {@link #caseIdentifier}.
         *
         * <p><b>Category:</b> Keyword alignment and capitalization</p>
         * <p><b>Default:</b> {@code null} (follows {@link #caseIdentifier}).</p>
         */
        public TCaseOption caseColumnName = null;

        /**
         * Converts unquoted table aliases where they are declared
         * ({@code orders o}, {@code (select ...) x}) and where they qualify a
         * column that name resolution resolves to that table ({@code o.id}). For
         * SQL that does not parse, and when this is null, table aliases follow
         * {@link #caseIdentifier}.
         *
         * <p><b>Category:</b> Keyword alignment and capitalization</p>
         * <p><b>Default:</b> {@code null} (follows {@link #caseIdentifier}).</p>
         */
        public TCaseOption caseTableAlias = null;

        /**
         * Converts unquoted column aliases where they are declared
         * ({@code AS OrderId}, SQL Server's {@code OrderId = expr}). A reference
         * to a column alias ({@code ORDER BY OrderId}) follows
         * {@link #caseIdentifier}. For SQL that does not parse, and when this is
         * null, column aliases follow {@link #caseIdentifier}.
         *
         * <p><b>Category:</b> Keyword alignment and capitalization</p>
         * <p><b>Default:</b> {@code null} (follows {@link #caseIdentifier}).</p>
         */
        public TCaseOption caseColumnAlias = null;

        /**
         * Converts double-quoted identifier contents while preserving the quote
         * characters. Quoted identifiers are frequently case-sensitive; use any
         * value other than no-change with care.
         *
         * <p><b>Category:</b> Keyword alignment and capitalization</p>
         * <p><b>Default:</b> {@link TCaseOption#CoNoChange}.</p>
         */
        public TCaseOption caseQuotedIdentifier = TCaseOption.CoNoChange;

        /**
         * Converts tokens recognized by the parser as function names, including
         * built-in and user-defined calls where classification is available.
         *
         * <p><b>Category:</b> Keyword alignment and capitalization</p>
         * <p><b>Default:</b> {@link TCaseOption#CoInitCap}.</p>
         */
        public TCaseOption caseFuncname = TCaseOption.CoInitCap;

        /**
         * Converts tokens recognized as datatype names. This classification takes
         * precedence over the general keyword and identifier case settings.
         *
         * <p><b>Category:</b> Keyword alignment and capitalization</p>
         * <p><b>Default:</b> {@link TCaseOption#CoUppercase}.</p>
         */
        public TCaseOption caseDatatype = TCaseOption.CoUppercase;

        /**
         * Inserts one space on both sides of recognized binary arithmetic and
         * comparison operators. Unary plus and minus are kept adjacent to their
         * operand regardless of this setting.
         *
         * <p><b>Category:</b> Whitespace and parentheses</p>
         * <p><b>Default:</b> {@code true}.</p>
         */
        public Boolean wsPaddingOperatorArithmetic = true;

        /**
         * Inserts one space just inside the parameter-list parentheses of CREATE
         * FUNCTION, PROCEDURE, PACKAGE, and TRIGGER declarations when parameters are
         * present. It does not affect ordinary function calls.
         *
         * <p><b>Category:</b> Whitespace and parentheses</p>
         * <p><b>Default:</b> {@code false}.</p>
         */
        public Boolean wsPaddingParenthesesInFunction = false;

        /**
         * Inserts one space just inside parentheses that group an expression, for
         * example {@code ( a + b )}. Subqueries, function calls, and datatype
         * parameters use separate options.
         *
         * <p><b>Category:</b> Whitespace and parentheses</p>
         * <p><b>Default:</b> {@code true}.</p>
         */
        public Boolean wsPaddingParenthesesInExpression = true;

        /**
         * Inserts one space just inside parentheses that enclose a formatted
         * subquery. Internal subquery line breaks and indentation are still produced
         * by the nested statement formatter.
         *
         * <p><b>Category:</b> Whitespace and parentheses</p>
         * <p><b>Default:</b> {@code false}.</p>
         */
        public Boolean wsPaddingParenthesesOfSubQuery = false;

        /**
         * Inserts one space just inside ordinary function-call parentheses. Stored-
         * routine declaration parentheses use
         * {@link #wsPaddingParenthesesInFunction} instead.
         *
         * <p><b>Category:</b> Whitespace and parentheses</p>
         * <p><b>Default:</b> {@code false}.</p>
         */
        public Boolean wsPaddingParenthesesInFunctionCall = false;

        /**
         * Inserts one space just inside datatype-parameter parentheses, for example
         * {@code VARCHAR( 20 )}. It applies only when the parser classifies the node
         * as a type name.
         *
         * <p><b>Category:</b> Whitespace and parentheses</p>
         * <p><b>Default:</b> {@code false}.</p>
         */
        public Boolean wsPaddingParenthesesOfTypename = false;

        /**
         * Places the AS keyword of each common table expression on a new line aligned
         * under the CTE name area. When false, AS follows the CTE header after one
         * space; the CTE query itself is formatted in both cases.
         *
         * <p><b>Category:</b> CTEs and declarations</p>
         * <p><b>Default:</b> {@code true}.</p>
         */
        public Boolean cteNewlineBeforeAs = true;

        /**
         * Places the first variable declaration on a new indented line after DECLARE.
         * Later declaration items are always stacked by the DECLARE formatter.
         *
         * <p><b>Category:</b> CTEs and declarations</p>
         * <p><b>Default:</b> {@code false}.</p>
         */
        public Boolean linebreakAfterDeclare = false;

        /**
         * Chooses stacked or wrapped layout for stored-routine, package, trigger, and
         * supported CREATE VIEW parameter declarations. Stacked parameters also have
         * their names/types aligned by the parameter formatter.
         *
         * <p><b>Category:</b> Routine declarations and EXEC</p>
         * <p><b>Default:</b> {@link TAlignStyle#AsStacked}.</p>
         */
        public TAlignStyle parametersStyle = TAlignStyle.AsStacked;

        /**
         * Positions commas for stacked stored-routine parameter declarations. It is
         * effective when {@link #parametersStyle} is stacked.
         *
         * <p><b>Category:</b> Routine declarations and EXEC</p>
         * <p><b>Default:</b> {@link TLinefeedsCommaOption#LfAfterComma}.</p>
         */
        public TLinefeedsCommaOption parametersComma = TLinefeedsCommaOption.LfAfterComma;

        /**
         * Places the opening parenthesis of a stored-routine parameter list on a new
         * line. The setting applies only when a parameter declaration list exists.
         *
         * <p><b>Category:</b> Routine declarations and EXEC</p>
         * <p><b>Default:</b> {@code false}.</p>
         */
        public Boolean beStyleFunctionLeftBEOnNewline = false;

        /**
         * Adds columns to the current indentation of a stored-routine opening
         * parenthesis moved to a new line. It is ignored unless
         * {@link #beStyleFunctionLeftBEOnNewline} is true.
         *
         * <p><b>Category:</b> Routine declarations and EXEC</p>
         * <p><b>Default:</b> {@code 0}.</p>
         */
        public Integer beStyleFunctionLeftBEIndentSize = 0;

        /**
         * Places the closing parenthesis of a stored-routine parameter list on a new
         * line. The setting applies only when a parameter declaration list exists.
         *
         * <p><b>Category:</b> Routine declarations and EXEC</p>
         * <p><b>Default:</b> {@code true}.</p>
         */
        public Boolean beStyleFunctionRightBEOnNewline = true;

        /**
         * Adds columns relative to the routine declaration when a parameter-list
         * closing parenthesis is moved to a new line. It is ignored unless
         * {@link #beStyleFunctionRightBEOnNewline} is true.
         *
         * <p><b>Category:</b> Routine declarations and EXEC</p>
         * <p><b>Default:</b> {@code 0}.</p>
         */
        public Integer beStyleFunctionRightBEIndentSize = 0;

        /**
         * Places the first stored-routine parameter on a new line and indents it one
         * general indentation level beyond its current parameter-list indentation.
         * Subsequent parameters follow the parameter style and comma settings.
         *
         * <p><b>Category:</b> Routine declarations and EXEC</p>
         * <p><b>Default:</b> {@code false}.</p>
         */
        public Boolean beStyleFunctionFirstParamInNewline = false;

        /**
         * Places the first SQL Server EXEC/EXECUTE argument on a new line, indented by
         * {@link #indentLen} from the statement. It does not control stored-routine
         * declaration parameters.
         *
         * <p><b>Category:</b> Routine declarations and EXEC</p>
         * <p><b>Default:</b> {@code true}.</p>
         */
        public Boolean linebreakBeforeParamInExec = true;

        /**
         * Determines how blank lines found between top-level statements are handled:
         * remove them, collapse them to one blank line, or preserve their count.
         * Statement-separating newlines themselves are always retained.
         *
         * <p><b>Category:</b> Blank lines and batches</p>
         * <p><b>Default:</b> {@link TEmptyLinesOption#EloMergeIntoOne}.</p>
         */
        public TEmptyLinesOption emptyLines = TEmptyLinesOption.EloMergeIntoOne;

        /**
         * Inserts a blank line between statements inside supported BEGIN/END batches.
         * It is applied in addition to the general {@link #emptyLines} policy.
         *
         * <p><b>Category:</b> Blank lines and batches</p>
         * <p><b>Default:</b> {@code false}.</p>
         */
        public Boolean insertBlankLineInBatchSqls = false;

        /**
         * Suppresses the formatter's otherwise automatic blank line between adjacent
         * SET or DECLARE-family statements. It does not remove ordinary separator
         * newlines and does not override unrelated batch blank-line insertion.
         *
         * <p><b>Category:</b> Blank lines and batches</p>
         * <p><b>Default:</b> {@code false}.</p>
         */
        public Boolean noEmptyLinesBetweenMultiSetStmts = false;

        /**
         * Prefixes every output line with a zero-padded line number. Width is based on
         * the total formatted line count; margins are controlled by the line-number
         * margin settings.
         *
         * <p><b>Category:</b> Line numbers</p>
         * <p><b>Default:</b> {@code false}.</p>
         */
        public Boolean linenumberEnabled = false;

        /**
         * Starts generated line numbers at zero when true, or one when false. It has
         * no effect unless {@link #linenumberEnabled} is enabled.
         *
         * <p><b>Category:</b> Line numbers</p>
         * <p><b>Default:</b> {@code false} (one-based numbering).</p>
         */
        public Boolean linenumberZeroBased = false;

        /**
         * Inserts this many spaces before each generated line number. It has no
         * effect unless {@link #linenumberEnabled} is enabled.
         *
         * <p><b>Category:</b> Line numbers</p>
         * <p><b>Default:</b> {@code 0}.</p>
         */
        public Integer linenumberLeftMargin = 0;

        /**
         * Inserts this many spaces between each generated line number and the SQL
         * text. It has no effect unless {@link #linenumberEnabled} is enabled.
         *
         * <p><b>Category:</b> Line numbers</p>
         * <p><b>Default:</b> {@code 2}.</p>
         */
        public Integer linenumberRightMargin = 2;

        /**
         * Chooses stacked or wrapped layout for argument lists in ordinary function
         * calls. This is independent from the stored-routine declaration parameter
         * style.
         *
         * <p><b>Category:</b> Function calls</p>
         * <p><b>Default:</b> {@link TAlignStyle#AsWrapped}.</p>
         */
        public TAlignStyle functionCallParametersStyle = TAlignStyle.AsWrapped;

        /**
         * Positions commas when ordinary function-call arguments use stacked layout.
         * It has no line-break effect while
         * {@link #functionCallParametersStyle} is wrapped.
         *
         * <p><b>Category:</b> Function calls</p>
         * <p><b>Default:</b> {@link TLinefeedsCommaOption#LfAfterComma}.</p>
         */
        public TLinefeedsCommaOption functionCallParametersComma = TLinefeedsCommaOption.LfAfterComma;

        /**
         * Removes ordinary line and block comments before formatting and reparses the
         * modified token stream. Oracle optimizer hints beginning with {@code /*+}
         * are preserved. Because removal mutates the parser's token list, use a fresh
         * parser if the original comments are needed later.
         *
         * <p><b>Category:</b> Comments, compact mode, and wrapping</p>
         * <p><b>Default:</b> {@code false}.</p>
         */
        public Boolean removeComment = false;

        /**
         * Selects normal pretty-printing or compact output. {@code Cpmugly}
         * short-circuits statement-specific layout, normalizes the token stream, and
         * wraps only when {@link #lineWidth} is exceeded; most other layout options
         * are therefore ignored.
         *
         * <p><b>Category:</b> Comments, compact mode, and wrapping</p>
         * <p><b>Default:</b> {@link TCompactMode#CpmNone}.</p>
         */
        public TCompactMode compactMode = TCompactMode.CpmNone;

        /**
         * Sets the maximum line width used by compact mode. It is a soft limit:
         * indivisible tokens longer than the value can still exceed it. The active
         * normal pretty-printing pipeline does not currently use this field.
         *
         * <p><b>Category:</b> Comments, compact mode, and wrapping</p>
         * <p><b>Default:</b> {@code 99}.</p>
         */
        public Integer lineWidth = 99;

        /**
         * Limits how many items are stacked at once in large SELECT-style lists. When
         * a list exceeds the threshold, the comma processor packs several items per
         * line up to {@link #lineWidth} (a comment ends the line, and an item that
         * spans lines gets a line of its own) and alias alignment is skipped; use
         * {@link Integer#MAX_VALUE} to disable the threshold.
         *
         * <p><b>Category:</b> Comments, compact mode, and wrapping</p>
         * <p><b>Default:</b> {@code 20}. This option is available only in GSP Java.</p>
         */
        public Integer maxSelectListColumn = 20;

        private final static GOutputFmt defaultOutputFmt = GOutputFmt.ofSql;

        /**
         * Selects the renderer used after token formatting. The active formatter
         * supports {@link GOutputFmt#ofSql} and {@link GOutputFmt#ofhtml};
         * {@link GOutputFmt#ofUnknown} falls back to SQL, while the other legacy enum
         * values currently throw {@link UnsupportedOperationException}. Each
         * {@code FormatterFactory.pp} and {@code SqlFormatter.format} call prints as
         * its own option says, unless an output config was set with
         * {@code FormatterFactory.setOutputConfig}: that one is used by every such
         * call until it is set back to {@code null}. {@code FormatterFactory.pp2}
         * returns SQL whatever this option says.
         *
         * <p><b>Category:</b> Output rendering</p>
         * <p><b>Default:</b> {@link GOutputFmt#ofSql}.</p>
         *
         * @see GOutputFmt
         */
        public GOutputFmt outputFmt = defaultOutputFmt;

        /**
         * Replaces each literal tab in HTML output with this string. It is used only
         * by the Java HTML renderer ({@code outputFmt == ofhtml}) and is independent
         * of the tab-stop calculation controlled by {@link #useTab} and
         * {@link #tabSize}.
         *
         * <p><b>Category:</b> Output rendering</p>
         * <p><b>Default:</b> {@code "&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;"}.</p>
         */
        public String tabHtmlString = "&nbsp;&nbsp;&nbsp;&nbsp;";

        /**
         * Creates an option set for the supplied formatting-session id.
         *
         * @param sessionId cache key shared by components in one formatting call
         */
        public GFmtOpt( String sessionId )
        {
                this.sessionId = sessionId;
        }

}