window.go

// Copyright 2026 GoSQLX Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Package parser - window.go
// Window function parsing for the SQL parser.
// Includes OVER clause, PARTITION BY, ORDER BY, and frame specifications.

package parser

import (
	"strings"

	"github.com/ajitpratap0/GoSQLX/pkg/models"
	"github.com/ajitpratap0/GoSQLX/pkg/sql/ast"
	"github.com/ajitpratap0/GoSQLX/pkg/sql/keywords"
)

// SUM(salary) OVER (PARTITION BY dept ORDER BY date ROWS UNBOUNDED PRECEDING) -> window function with frame
func (p *Parser) parseFunctionCall(funcName string) (*ast.FunctionCall, error) {
	// Expect opening parenthesis
	if !p.isType(models.TokenTypeLParen) {
		return nil, p.expectedError("(")
	}
	p.advance() // Consume (

	// Parse function arguments
	var arguments []ast.Expression
	var distinct bool

	// Check for DISTINCT keyword
	if p.isType(models.TokenTypeDistinct) {
		distinct = true
		p.advance()
	}

	// Parse arguments if not empty
	if !p.isType(models.TokenTypeRParen) {
		for !p.isType(models.TokenTypeOrder) {
			// Named argument form: `name => expr` (Snowflake FLATTEN,
			// BigQuery, Oracle, PostgreSQL procedural calls). Detect by a
			// bare identifier immediately followed by =>.
			if p.isIdentifier() &&
				p.peekToken().Token.Type == models.TokenTypeRArrow {
				namePos := p.currentLocation()
				argName := p.currentToken.Token.Value
				p.advance() // name
				p.advance() // =>
				value, err := p.parseExpression()
				if err != nil {
					return nil, err
				}
				arguments = append(arguments, &ast.NamedArgument{
					Name:  argName,
					Value: value,
					Pos:   namePos,
				})
				if p.isType(models.TokenTypeComma) {
					p.advance()
					continue
				}
				if p.isType(models.TokenTypeRParen) {
					break
				}
				return nil, p.expectedError(", or )")
			}

			arg, err := p.parseExpression()
			if err != nil {
				return nil, err
			}
			arguments = append(arguments, arg)

			// Check for comma or end of arguments
			if p.isType(models.TokenTypeComma) {
				p.advance() // Consume comma
			} else if p.isType(models.TokenTypeRParen) || p.isType(models.TokenTypeOrder) {
				break
			} else if strings.ToUpper(p.currentToken.Token.Value) == "SEPARATOR" {
				// MySQL GROUP_CONCAT SEPARATOR clause
				p.advance() // Consume SEPARATOR
				sepArg, err := p.parseExpression()
				if err != nil {
					return nil, err
				}
				arguments = append(arguments, sepArg)
				break
			} else {
				return nil, p.expectedError(", or )")
			}
		}
	}

	// Parse ORDER BY clause inside aggregate functions (STRING_AGG, ARRAY_AGG, etc.)
	// Syntax: STRING_AGG(name, ', ' ORDER BY name ASC)
	var orderByExprs []ast.OrderByExpression
	if p.isType(models.TokenTypeOrder) {
		p.advance() // Consume ORDER

		// Expect BY keyword
		if !p.isType(models.TokenTypeBy) {
			return nil, p.expectedError("BY after ORDER")
		}
		p.advance() // Consume BY

		// Parse order expressions
		for {
			expr, err := p.parseExpression()
			if err != nil {
				return nil, err
			}

			// Create OrderByExpression with defaults
			orderByExpr := ast.OrderByExpression{
				Expression: expr,
				Ascending:  true, // Default to ASC
				NullsFirst: nil,  // Default behavior (database-specific)
			}

			// Check for ASC/DESC after the expression
			if p.isType(models.TokenTypeAsc) {
				orderByExpr.Ascending = true
				p.advance() // Consume ASC
			} else if p.isType(models.TokenTypeDesc) {
				orderByExpr.Ascending = false
				p.advance() // Consume DESC
			}

			// Check for NULLS FIRST/LAST
			nullsFirst, err := p.parseNullsClause()
			if err != nil {
				return nil, err
			}
			orderByExpr.NullsFirst = nullsFirst

			orderByExprs = append(orderByExprs, orderByExpr)

			// Check for comma (multiple order columns) or end
			if p.isType(models.TokenTypeComma) {
				p.advance() // Consume comma
			} else if p.isType(models.TokenTypeRParen) {
				break
			} else if strings.EqualFold(p.currentToken.Token.Value, "SEPARATOR") {
				break // Let SEPARATOR be handled below
			} else {
				return nil, p.expectedError(", or )")
			}
		}
	}

	// Handle MySQL SEPARATOR clause (GROUP_CONCAT)
	if strings.EqualFold(p.currentToken.Token.Value, "SEPARATOR") {
		p.advance() // Consume SEPARATOR
		sepExpr, err := p.parseExpression()
		if err != nil {
			return nil, err
		}
		arguments = append(arguments, sepExpr)
	}

	// Expect closing parenthesis
	if !p.isType(models.TokenTypeRParen) {
		return nil, p.expectedError(")")
	}
	p.advance() // Consume )

	// Create function call
	funcCall := &ast.FunctionCall{
		Name:      funcName,
		Arguments: arguments,
		Distinct:  distinct,
		OrderBy:   orderByExprs,
	}

	// ClickHouse parametric aggregates: funcName(params)(args).
	// e.g. quantileTDigest(0.95)(value), topK(10)(name).
	// What we just parsed becomes Parameters; the next paren group is the
	// real arguments. Gated to ClickHouse to avoid false positives.
	if p.dialect == string(keywords.DialectClickHouse) && p.isType(models.TokenTypeLParen) {
		funcCall.Parameters = funcCall.Arguments
		funcCall.Arguments = nil
		p.advance() // Consume second (
		if !p.isType(models.TokenTypeRParen) {
			for {
				arg, err := p.parseExpression()
				if err != nil {
					return nil, err
				}
				funcCall.Arguments = append(funcCall.Arguments, arg)
				if p.isType(models.TokenTypeComma) {
					p.advance()
				} else if p.isType(models.TokenTypeRParen) {
					break
				} else {
					return nil, p.expectedError(", or )")
				}
			}
		}
		if !p.isType(models.TokenTypeRParen) {
			return nil, p.expectedError(")")
		}
		p.advance() // Consume second )
	}

	// Check for IGNORE NULLS / RESPECT NULLS (SQL:2016 null treatment).
	// Used by LAG, LEAD, FIRST_VALUE, LAST_VALUE, NTH_VALUE in Snowflake,
	// Oracle, BigQuery, etc. IGNORE arrives as TokenTypeKeyword; RESPECT is
	// not in any keyword list and arrives as TokenTypeIdentifier. NULLS has
	// its own token type.
	if p.currentToken.Token.Type == models.TokenTypeKeyword ||
		p.currentToken.Token.Type == models.TokenTypeIdentifier {
		upper := strings.ToUpper(p.currentToken.Token.Value)
		if (upper == "IGNORE" || upper == "RESPECT") &&
			p.peekToken().Token.Type == models.TokenTypeNulls {
			funcCall.NullTreatment = upper + " NULLS"
			p.advance() // IGNORE / RESPECT
			p.advance() // NULLS
		}
	}

	// Check for WITHIN GROUP clause (SQL:2003 ordered-set aggregates)
	// Syntax: WITHIN GROUP (ORDER BY expression [ASC|DESC] [NULLS FIRST|LAST])
	// Used with: PERCENTILE_CONT, PERCENTILE_DISC, MODE, LISTAGG, etc.
	if p.isType(models.TokenTypeWithin) {
		p.advance() // Consume WITHIN

		// Expect GROUP keyword
		if !p.isType(models.TokenTypeGroup) {
			return nil, p.expectedError("GROUP after WITHIN")
		}
		p.advance() // Consume GROUP

		// Expect opening parenthesis
		if !p.isType(models.TokenTypeLParen) {
			return nil, p.expectedError("( after WITHIN GROUP")
		}
		p.advance() // Consume (

		// Expect ORDER BY clause
		if !p.isType(models.TokenTypeOrder) {
			return nil, p.expectedError("ORDER BY in WITHIN GROUP")
		}
		p.advance() // Consume ORDER

		if !p.isType(models.TokenTypeBy) {
			return nil, p.expectedError("BY after ORDER")
		}
		p.advance() // Consume BY

		// Parse order expressions
		var withinGroupOrderBy []ast.OrderByExpression
		for {
			expr, err := p.parseExpression()
			if err != nil {
				return nil, err
			}

			// Create OrderByExpression with defaults
			orderByExpr := ast.OrderByExpression{
				Expression: expr,
				Ascending:  true, // Default to ASC
				NullsFirst: nil,  // Default behavior (database-specific)
			}

			// Check for ASC/DESC after the expression
			if p.isType(models.TokenTypeAsc) {
				orderByExpr.Ascending = true
				p.advance() // Consume ASC
			} else if p.isType(models.TokenTypeDesc) {
				orderByExpr.Ascending = false
				p.advance() // Consume DESC
			}

			// Check for NULLS FIRST/LAST
			nullsFirst, err := p.parseNullsClause()
			if err != nil {
				return nil, err
			}
			orderByExpr.NullsFirst = nullsFirst

			withinGroupOrderBy = append(withinGroupOrderBy, orderByExpr)

			// Check for comma (multiple order columns) or end
			if p.isType(models.TokenTypeComma) {
				p.advance() // Consume comma
			} else if p.isType(models.TokenTypeRParen) {
				break
			} else {
				return nil, p.expectedError(", or )")
			}
		}

		// Expect closing parenthesis
		if !p.isType(models.TokenTypeRParen) {
			return nil, p.expectedError(") after WITHIN GROUP ORDER BY")
		}
		p.advance() // Consume )

		funcCall.WithinGroup = withinGroupOrderBy
	}

	// Check for FILTER clause (SQL:2003 T612)
	// Syntax: FILTER (WHERE condition)
	if p.isType(models.TokenTypeFilter) {
		p.advance() // Consume FILTER

		// Expect opening parenthesis
		if !p.isType(models.TokenTypeLParen) {
			return nil, p.expectedError("( after FILTER")
		}
		p.advance() // Consume (

		// Expect WHERE keyword
		if !p.isType(models.TokenTypeWhere) {
			return nil, p.expectedError("WHERE after FILTER (")
		}
		p.advance() // Consume WHERE

		// Parse filter condition expression
		filterExpr, err := p.parseExpression()
		if err != nil {
			return nil, err
		}
		funcCall.Filter = filterExpr

		// Expect closing parenthesis
		if !p.isType(models.TokenTypeRParen) {
			return nil, p.expectedError(") after FILTER condition")
		}
		p.advance() // Consume )
	}

	// Check for OVER clause (window function)
	if p.isType(models.TokenTypeOver) {
		p.advance() // Consume OVER

		windowSpec, err := p.parseWindowSpec()
		if err != nil {
			return nil, err
		}
		funcCall.Over = windowSpec
	}

	return funcCall, nil
}

// parseWindowSpec parses a window specification (PARTITION BY, ORDER BY, frame clause).
// Supports both inline specs OVER (...) and named window references OVER w (SQL:2003 §7.11).
func (p *Parser) parseWindowSpec() (*ast.WindowSpec, error) {
	// Named window reference: OVER w - bare identifier, no parentheses.
	// This must be checked before the '(' path so that e.g. OVER w is not
	// mistakenly rejected.
	if p.isIdentifier() {
		spec := &ast.WindowSpec{Name: p.currentToken.Token.Value}
		p.advance()
		return spec, nil
	}

	// Expect opening parenthesis
	if !p.isType(models.TokenTypeLParen) {
		return nil, p.expectedError("(")
	}
	p.advance() // Consume (

	windowSpec := &ast.WindowSpec{}

	// Parse PARTITION BY clause
	if p.isType(models.TokenTypePartition) {
		p.advance() // Consume PARTITION
		if !p.isType(models.TokenTypeBy) {
			return nil, p.expectedError("BY after PARTITION")
		}
		p.advance() // Consume BY

		// Parse partition expressions
		for {
			expr, err := p.parseExpression()
			if err != nil {
				return nil, err
			}
			windowSpec.PartitionBy = append(windowSpec.PartitionBy, expr)

			if p.isType(models.TokenTypeComma) {
				p.advance() // Consume comma
			} else {
				break
			}
		}
	}

	// Parse ORDER BY clause
	if p.isType(models.TokenTypeOrder) {
		p.advance() // Consume ORDER
		if !p.isType(models.TokenTypeBy) {
			return nil, p.expectedError("BY after ORDER")
		}
		p.advance() // Consume BY

		// Parse order expressions
		for {
			expr, err := p.parseExpression()
			if err != nil {
				return nil, err
			}

			// Create OrderByExpression with defaults
			orderByExpr := ast.OrderByExpression{
				Expression: expr,
				Ascending:  true, // Default to ASC
				NullsFirst: nil,  // Default behavior (database-specific)
			}

			// Check for ASC/DESC after the expression
			if p.isType(models.TokenTypeAsc) {
				orderByExpr.Ascending = true
				p.advance() // Consume ASC
			} else if p.isType(models.TokenTypeDesc) {
				orderByExpr.Ascending = false
				p.advance() // Consume DESC
			}

			// Check for NULLS FIRST/LAST
			nullsFirst, err := p.parseNullsClause()
			if err != nil {
				return nil, err
			}
			orderByExpr.NullsFirst = nullsFirst

			windowSpec.OrderBy = append(windowSpec.OrderBy, orderByExpr)

			if p.isType(models.TokenTypeComma) {
				p.advance() // Consume comma
			} else {
				break
			}
		}
	}

	// Parse frame clause (ROWS/RANGE with bounds)
	if p.isAnyType(models.TokenTypeRows, models.TokenTypeRange) {
		frameType := p.currentToken.Token.Value
		p.advance() // Consume ROWS/RANGE

		frameClause, err := p.parseWindowFrame(frameType)
		if err != nil {
			return nil, err
		}
		windowSpec.FrameClause = frameClause
	}

	// Expect closing parenthesis
	if !p.isType(models.TokenTypeRParen) {
		return nil, p.expectedError(")")
	}
	p.advance() // Consume )

	return windowSpec, nil
}

// parseWindowFrame parses a window frame clause
func (p *Parser) parseWindowFrame(frameType string) (*ast.WindowFrame, error) {
	frame := &ast.WindowFrame{
		Type: frameType,
	}

	// Parse frame bounds
	if p.isType(models.TokenTypeBetween) {
		p.advance() // Consume BETWEEN

		// Parse start bound
		startBound, err := p.parseFrameBound()
		if err != nil {
			return nil, err
		}
		frame.Start = *startBound

		// Expect AND
		if !p.isType(models.TokenTypeAnd) {
			return nil, p.expectedError("AND")
		}
		p.advance() // Consume AND

		// Parse end bound
		endBound, err := p.parseFrameBound()
		if err != nil {
			return nil, err
		}
		frame.End = endBound
	} else {
		// Single bound (implies CURRENT ROW as end)
		startBound, err := p.parseFrameBound()
		if err != nil {
			return nil, err
		}
		frame.Start = *startBound
		// End is nil for single bound
	}

	return frame, nil
}

// parseFrameBound parses a window frame bound
func (p *Parser) parseFrameBound() (*ast.WindowFrameBound, error) {
	bound := &ast.WindowFrameBound{}

	if p.isType(models.TokenTypeUnbounded) {
		p.advance() // Consume UNBOUNDED
		if p.isType(models.TokenTypePreceding) {
			bound.Type = "UNBOUNDED PRECEDING"
			p.advance() // Consume PRECEDING
		} else if p.isType(models.TokenTypeFollowing) {
			bound.Type = "UNBOUNDED FOLLOWING"
			p.advance() // Consume FOLLOWING
		} else {
			return nil, p.expectedError("PRECEDING or FOLLOWING after UNBOUNDED")
		}
	} else if p.isType(models.TokenTypeCurrent) {
		p.advance() // Consume CURRENT
		if !p.isType(models.TokenTypeRow) {
			return nil, p.expectedError("ROW after CURRENT")
		}
		bound.Type = "CURRENT ROW"
		p.advance() // Consume ROW
	} else {
		// Numeric bound
		expr, err := p.parseExpression()
		if err != nil {
			return nil, err
		}
		bound.Value = expr

		if p.isType(models.TokenTypePreceding) {
			bound.Type = "PRECEDING"
			p.advance() // Consume PRECEDING
		} else if p.isType(models.TokenTypeFollowing) {
			bound.Type = "FOLLOWING"
			p.advance() // Consume FOLLOWING
		} else {
			return nil, p.expectedError("PRECEDING or FOLLOWING after numeric value")
		}
	}

	return bound, nil
}

// parseNullsClause parses the optional NULLS FIRST/LAST clause in ORDER BY expressions.
// Returns a pointer to bool indicating null ordering: true for NULLS FIRST, false for NULLS LAST, nil if not specified.
func (p *Parser) parseNullsClause() (*bool, error) {
	if p.isType(models.TokenTypeNulls) {
		p.advance() // Consume NULLS
		if p.isType(models.TokenTypeFirst) {
			t := true
			p.advance() // Consume FIRST
			return &t, nil
		} else if p.isType(models.TokenTypeLast) {
			f := false
			p.advance() // Consume LAST
			return &f, nil
		} else {
			return nil, p.expectedError("FIRST or LAST after NULLS")
		}
	}
	return nil, nil
}

// parseGroupingExpressionList parses a parenthesized, comma-separated list of expressions