// Charter Parser - 语法分析器模块
// 将Token流转换为AST

pub mod ast;

use crate::lexer::Token;
use ast::*;
use nac_udm::prelude::*;
use nac_udm::primitives::SovereigntyType;
use thiserror::Error;

#[derive(Error, Debug)]
#[allow(dead_code)]
pub enum ParseError {
    #[error("意外的Token: 期望 {expected}, 实际 {actual:?}")]
    UnexpectedToken { expected: String, actual: String },
    
    #[error("意外的文件结束")]
    UnexpectedEOF,
    
    #[error("无效的类型注解")]
    InvalidTypeAnnotation,
    
    #[error("无效的表达式")]
    InvalidExpression,
    
    #[error("缺少GNACS声明")]
    MissingGNACSDeclaration,
    
    #[error("无效的GNACS编码: {0}")]
    InvalidGNACSCode(String),
}

pub struct Parser {
    tokens: Vec<Token>,
    current: usize,
}

impl Parser {
    pub fn new(tokens: Vec<Token>) -> Self {
        Self { tokens, current: 0 }
    }
    
    fn is_at_end(&self) -> bool {
        self.current >= self.tokens.len()
    }
    
    fn peek(&self) -> Option<&Token> {
        self.tokens.get(self.current)
    }
    
    fn advance(&mut self) -> Option<&Token> {
        if !self.is_at_end() {
            self.current += 1;
            self.tokens.get(self.current - 1)
        } else {
            None
        }
    }
    
    fn expect(&mut self, expected: Token) -> Result<(), ParseError> {
        if let Some(token) = self.peek() {
            if std::mem::discriminant(token) == std::mem::discriminant(&expected) {
                self.advance();
                Ok(())
            } else {
                Err(ParseError::UnexpectedToken {
                    expected: format!("{:?}", expected),
                    actual: format!("{:?}", token),
                })
            }
        } else {
            Err(ParseError::UnexpectedEOF)
        }
    }
    
    pub fn parse_program(&mut self) -> Result<Program, ParseError> {
        let mut items = Vec::new();
        
        while !self.is_at_end() {
            items.push(self.parse_top_level_item()?);
        }
        
        Ok(Program { items })
    }
    
    fn parse_top_level_item(&mut self) -> Result<TopLevelItem, ParseError> {
        match self.peek() {
            Some(Token::Module) => {
                self.advance();
                let name = self.parse_identifier()?;
                self.expect(Token::Semicolon)?;
                Ok(TopLevelItem::Module(ModuleDeclaration { name }))
            }
            Some(Token::Import) => {
                self.advance();
                let path = self.parse_string_literal()?;
                self.expect(Token::Semicolon)?;
                Ok(TopLevelItem::Import(ImportStatement { path }))
            }
            Some(Token::Asset) => {
                Ok(TopLevelItem::Asset(self.parse_asset_definition()?))
            }
            Some(Token::Contract) => {
                Ok(TopLevelItem::Contract(self.parse_contract_definition()?))
            }
            Some(Token::Pub) | Some(Token::Public) | Some(Token::Fn) => {
                Ok(TopLevelItem::Function(self.parse_function_declaration()?))
            }
            _ => Err(ParseError::UnexpectedToken {
                expected: "module, import, asset, contract, or function".to_string(),
                actual: format!("{:?}", self.peek()),
            }),
        }
    }
    
    fn parse_asset_definition(&mut self) -> Result<AssetDefinition, ParseError> {
        self.expect(Token::Asset)?;
        let name = self.parse_identifier()?;
        self.expect(Token::LeftBrace)?;
        
        // 解析GNACS声明（必须）
        self.expect(Token::Gnacs)?;
        self.expect(Token::Colon)?;
        let gnacs_hex = self.parse_hex_number()?;
        // 使用NAC UDM的GNACSCode::from_hex创建
        let gnacs_code = GNACSCode::from_hex(&gnacs_hex)
            .map_err(|e| ParseError::InvalidGNACSCode(e))?;
        self.expect(Token::Semicolon)?;
        
        // 解析主权声明（可选）
        let sovereignty = if matches!(self.peek(), Some(Token::Sovereignty)) {
            self.advance();
            self.expect(Token::Colon)?;
            let sov = self.parse_sovereignty_type()?;
            self.expect(Token::Semicolon)?;
            Some(sov)
        } else {
            None
        };
        
        // 解析字段
        let mut fields = Vec::new();
        while !matches!(self.peek(), Some(Token::RightBrace) | Some(Token::Public) | Some(Token::Private) | Some(Token::Fn)) {
            fields.push(self.parse_field_declaration()?);
            self.expect(Token::Semicolon)?;
        }
        
        // 解析方法
        let mut methods = Vec::new();
        while matches!(self.peek(), Some(Token::Public) | Some(Token::Private) | Some(Token::Fn)) {
            methods.push(self.parse_method_declaration()?);
        }
        
        self.expect(Token::RightBrace)?;
        
        Ok(AssetDefinition {
            name,
            gnacs_code,
            sovereignty,
            fields,
            methods,
        })
    }
    
    fn parse_contract_definition(&mut self) -> Result<ContractDefinition, ParseError> {
        self.expect(Token::Contract)?;
        let name = self.parse_identifier()?;
        self.expect(Token::LeftBrace)?;
        
        // 解析字段
        let mut fields = Vec::new();
        while !matches!(self.peek(), Some(Token::RightBrace) | Some(Token::Public) | Some(Token::Private) | Some(Token::Fn)) {
            fields.push(self.parse_field_declaration()?);
            self.expect(Token::Semicolon)?;
        }
        
        // 解析方法
        let mut methods = Vec::new();
        while matches!(self.peek(), Some(Token::Public) | Some(Token::Private) | Some(Token::Fn)) {
            methods.push(self.parse_method_declaration()?);
        }
        
        self.expect(Token::RightBrace)?;
        
        Ok(ContractDefinition {
            name,
            fields,
            methods,
        })
    }
    
    fn parse_field_declaration(&mut self) -> Result<FieldDeclaration, ParseError> {
        let name = self.parse_identifier()?;
        self.expect(Token::Colon)?;
        let type_annotation = self.parse_type_annotation()?;
        
        Ok(FieldDeclaration {
            name,
            type_annotation,
        })
    }
    
    fn parse_function_declaration(&mut self) -> Result<FunctionDeclaration, ParseError> {
        // 解析修饰符
        let mut modifiers = Vec::new();
        while let Some(modifier) = self.parse_method_modifier() {
            modifiers.push(modifier);
        }
        
        self.expect(Token::Fn)?;
        let name = self.parse_identifier()?;
        self.expect(Token::LeftParen)?;
        
        // 解析参数
        let mut parameters = Vec::new();
        if !matches!(self.peek(), Some(Token::RightParen)) {
            loop {
                parameters.push(self.parse_parameter()?);
                if matches!(self.peek(), Some(Token::Comma)) {
                    self.advance();
                } else {
                    break;
                }
            }
        }
        self.expect(Token::RightParen)?;
        
        // 解析返回类型
        let return_type = if matches!(self.peek(), Some(Token::Arrow)) {
            self.advance();
            Some(self.parse_type_annotation()?)
        } else {
            None
        };
        
        // 解析函数体
        let body = self.parse_block()?;
        
        Ok(FunctionDeclaration {
            modifiers,
            name,
            parameters,
            return_type,
            body,
        })
    }
    
    fn parse_method_declaration(&mut self) -> Result<MethodDeclaration, ParseError> {
        // 解析修饰符
        let mut modifiers = Vec::new();
        while let Some(modifier) = self.parse_method_modifier() {
            modifiers.push(modifier);
        }
        
        self.expect(Token::Fn)?;
        let name = self.parse_identifier()?;
        self.expect(Token::LeftParen)?;
        
        // 解析参数
        let mut parameters = Vec::new();
        if !matches!(self.peek(), Some(Token::RightParen)) {
            loop {
                parameters.push(self.parse_parameter()?);
                if matches!(self.peek(), Some(Token::Comma)) {
                    self.advance();
                } else {
                    break;
                }
            }
        }
        self.expect(Token::RightParen)?;
        
        // 解析返回类型
        let return_type = if matches!(self.peek(), Some(Token::Arrow)) {
            self.advance();
            Some(self.parse_type_annotation()?)
        } else {
            None
        };
        
        // 解析requires子句
        let requires = if matches!(self.peek(), Some(Token::Requires)) {
            self.advance();
            self.expect(Token::LeftBrace)?;
            let mut exprs = Vec::new();
            while !matches!(self.peek(), Some(Token::RightBrace)) {
                exprs.push(self.parse_expression()?);
                self.expect(Token::Semicolon)?;
            }
            self.expect(Token::RightBrace)?;
            exprs
        } else {
            Vec::new()
        };
        
        // 解析ensures子句
        let ensures = if matches!(self.peek(), Some(Token::Ensures)) {
            self.advance();
            self.expect(Token::LeftBrace)?;
            let mut exprs = Vec::new();
            while !matches!(self.peek(), Some(Token::RightBrace)) {
                exprs.push(self.parse_expression()?);
                self.expect(Token::Semicolon)?;
            }
            self.expect(Token::RightBrace)?;
            exprs
        } else {
            Vec::new()
        };
        
        // 解析方法体
        let body = self.parse_block()?;
        
        Ok(MethodDeclaration {
            modifiers,
            name,
            parameters,
            return_type,
            requires,
            ensures,
            body,
        })
    }
    
    fn parse_method_modifier(&mut self) -> Option<MethodModifier> {
        match self.peek() {
            Some(Token::Pub) | Some(Token::Public) => {
                self.advance();
                Some(MethodModifier::Public)
            }
            Some(Token::Private) => {
                self.advance();
                Some(MethodModifier::Private)
            }
            Some(Token::Internal) => {
                self.advance();
                Some(MethodModifier::Internal)
            }
            Some(Token::Payable) => {
                self.advance();
                Some(MethodModifier::Payable)
            }
            Some(Token::View) => {
                self.advance();
                Some(MethodModifier::View)
            }
            Some(Token::Pure) => {
                self.advance();
                Some(MethodModifier::Pure)
            }
            _ => None,
        }
    }
    
    fn parse_parameter(&mut self) -> Result<Parameter, ParseError> {
        let name = self.parse_identifier()?;
        self.expect(Token::Colon)?;
        let type_annotation = self.parse_type_annotation()?;
        
        Ok(Parameter {
            name,
            type_annotation,
        })
    }
    
    fn parse_type_annotation(&mut self) -> Result<TypeAnnotation, ParseError> {
        // 检查是否是引用类型
        if matches!(self.peek(), Some(Token::Ampersand)) {
            self.advance();
            let inner_type = self.parse_type_annotation()?;
            return Ok(TypeAnnotation::Reference(Box::new(inner_type)));
        }
        
        let base_type = match self.peek() {
            Some(Token::Uint8) => { self.advance(); TypeAnnotation::Uint8 }
            Some(Token::Uint16) => { self.advance(); TypeAnnotation::Uint16 }
            Some(Token::Uint32) => { self.advance(); TypeAnnotation::Uint32 }
            Some(Token::Uint64) => { self.advance(); TypeAnnotation::Uint64 }
            Some(Token::Uint128) => { self.advance(); TypeAnnotation::Uint128 }
            Some(Token::Uint256) => { self.advance(); TypeAnnotation::Uint256 }
            Some(Token::Int8) => { self.advance(); TypeAnnotation::Int8 }
            Some(Token::Int16) => { self.advance(); TypeAnnotation::Int16 }
            Some(Token::Int32) => { self.advance(); TypeAnnotation::Int32 }
            Some(Token::Int64) => { self.advance(); TypeAnnotation::Int64 }
            Some(Token::Int128) => { self.advance(); TypeAnnotation::Int128 }
            Some(Token::Int256) => { self.advance(); TypeAnnotation::Int256 }
            Some(Token::Bool) => { self.advance(); TypeAnnotation::Bool }
            Some(Token::String) => { self.advance(); TypeAnnotation::String }
            Some(Token::Bytes) => { self.advance(); TypeAnnotation::Bytes }
            Some(Token::Address) => { self.advance(); TypeAnnotation::Address }
            Some(Token::Hash) => { self.advance(); TypeAnnotation::Hash }
            Some(Token::Timestamp) => { self.advance(); TypeAnnotation::Timestamp }
            Some(Token::DID) => { self.advance(); TypeAnnotation::DID }
            Some(Token::GNACSCode) => { self.advance(); TypeAnnotation::GNACSCode }
            Some(Token::ConstitutionalReceipt) => { self.advance(); TypeAnnotation::ConstitutionalReceipt }
            Some(Token::AssetInstance) => { self.advance(); TypeAnnotation::AssetInstance }
            Some(Token::ACC20) => { self.advance(); TypeAnnotation::ACC20 }
            Some(Token::ACC721) => { self.advance(); TypeAnnotation::ACC721 }
            Some(Token::ACC1155) => { self.advance(); TypeAnnotation::ACC1155 }
            Some(Token::ACCRWA) => { self.advance(); TypeAnnotation::ACCRWA }
            Some(Token::Identifier(name)) if name == "Vec" => {
                self.advance();
                self.expect(Token::Less)?;
                let inner_type = self.parse_type_annotation()?;
                self.expect(Token::Greater)?;
                TypeAnnotation::Vec(Box::new(inner_type))
            }
            _ => return Err(ParseError::InvalidTypeAnnotation),
        };
        
        // 检查是否是数组类型
        if matches!(self.peek(), Some(Token::LeftBracket)) {
            self.advance();
            let size = if let Some(Token::Integer(n)) = self.peek() {
                let size = *n as usize;
                self.advance();
                Some(size)
            } else {
                None
            };
            self.expect(Token::RightBracket)?;
            Ok(TypeAnnotation::Array(Box::new(base_type), size))
        } else {
            Ok(base_type)
        }
    }
    
    fn parse_sovereignty_type(&mut self) -> Result<SovereigntyType, ParseError> {
        match self.peek() {
            Some(Token::A0) => { self.advance(); Ok(SovereigntyType::A0) }
            Some(Token::C0) => { self.advance(); Ok(SovereigntyType::C0) }
            Some(Token::C1) => { self.advance(); Ok(SovereigntyType::C1) }
            Some(Token::C2) => { self.advance(); Ok(SovereigntyType::C2) }
            Some(Token::D0) => { self.advance(); Ok(SovereigntyType::D0) }
            Some(Token::D1) => { self.advance(); Ok(SovereigntyType::D1) }
            Some(Token::D2) => { self.advance(); Ok(SovereigntyType::D2) }
            _ => Err(ParseError::UnexpectedToken {
                expected: "sovereignty type (A0, C0, C1, C2, D0, D1, D2)".to_string(),
                actual: format!("{:?}", self.peek()),
            }),
        }
    }
    
    fn parse_block(&mut self) -> Result<Block, ParseError> {
        self.expect(Token::LeftBrace)?;
        let mut statements = Vec::new();
        
        while !matches!(self.peek(), Some(Token::RightBrace)) {
            statements.push(self.parse_statement()?);
        }
        
        self.expect(Token::RightBrace)?;
        Ok(Block { statements })
    }
    
    fn parse_statement(&mut self) -> Result<Statement, ParseError> {
        match self.peek() {
            Some(Token::Let) => {
                self.advance();
                
                // 检查是否有mut关键字
                let mutable = if matches!(self.peek(), Some(Token::Mut)) {
                    self.advance();
                    true
                } else {
                    false
                };
                
                let name = self.parse_identifier()?;
                
                let type_annotation = if matches!(self.peek(), Some(Token::Colon)) {
                    self.advance();
                    Some(self.parse_type_annotation()?)
                } else {
                    None
                };
                
                self.expect(Token::Assign)?;
                let value = self.parse_expression()?;
                self.expect(Token::Semicolon)?;
                
                Ok(Statement::Let(LetStatement {
                    mutable,
                    name,
                    type_annotation,
                    value,
                }))
            }
            Some(Token::If) => {
                self.advance();
                let condition = self.parse_expression()?;
                let then_block = self.parse_block()?;
                
                let else_block = if matches!(self.peek(), Some(Token::Else)) {
                    self.advance();
                    Some(self.parse_block()?)
                } else {
                    None
                };
                
                Ok(Statement::If(IfStatement {
                    condition,
                    then_block,
                    else_block,
                }))
            }
            Some(Token::For) => {
                self.advance();
                let variable = self.parse_identifier()?;
                self.expect(Token::In)?;
                let iterable = self.parse_expression()?;
                let body = self.parse_block()?;
                
                Ok(Statement::For(ForStatement {
                    variable,
                    iterable,
                    body,
                }))
            }
            Some(Token::While) => {
                self.advance();
                let condition = self.parse_expression()?;
                let body = self.parse_block()?;
                
                Ok(Statement::While(WhileStatement {
                    condition,
                    body,
                }))
            }
            Some(Token::Return) => {
                self.advance();
                let value = if matches!(self.peek(), Some(Token::Semicolon)) {
                    None
                } else {
                    Some(self.parse_expression()?)
                };
                self.expect(Token::Semicolon)?;
                
                Ok(Statement::Return(ReturnStatement { value }))
            }
            Some(Token::Emit) => {
                self.advance();
                let event_name = self.parse_identifier()?;
                self.expect(Token::LeftParen)?;
                
                let mut arguments = Vec::new();
                if !matches!(self.peek(), Some(Token::RightParen)) {
                    loop {
                        arguments.push(self.parse_expression()?);
                        if matches!(self.peek(), Some(Token::Comma)) {
                            self.advance();
                        } else {
                            break;
                        }
                    }
                }
                
                self.expect(Token::RightParen)?;
                self.expect(Token::Semicolon)?;
                
                Ok(Statement::Emit(EmitStatement {
                    event_name,
                    arguments,
                }))
            }
            Some(Token::RequireCR) => {
                self.advance();
                self.expect(Token::LeftParen)?;
                let expr = self.parse_expression()?;
                self.expect(Token::RightParen)?;
                self.expect(Token::Semicolon)?;
                
                Ok(Statement::RequireCR(expr))
            }
            Some(Token::VerifyCR) => {
                self.advance();
                self.expect(Token::LeftParen)?;
                let expr = self.parse_expression()?;
                self.expect(Token::RightParen)?;
                self.expect(Token::Semicolon)?;
                
                Ok(Statement::VerifyCR(expr))
            }
            Some(Token::Identifier(_)) => {
                // 可能是赋值或表达式语句
                let start_pos = self.current;
                let name = self.parse_identifier()?;
                
                if matches!(self.peek(), Some(Token::Assign)) {
                    self.advance();
                    let value = self.parse_expression()?;
                    self.expect(Token::Semicolon)?;
                    
                    Ok(Statement::Assign(AssignStatement {
                        target: name,
                        value,
                    }))
                } else {
                    // 回退并解析为表达式语句
                    self.current = start_pos;
                    let expr = self.parse_expression()?;
                    self.expect(Token::Semicolon)?;
                    Ok(Statement::Expression(expr))
                }
            }
            _ => {
                let expr = self.parse_expression()?;
                self.expect(Token::Semicolon)?;
                Ok(Statement::Expression(expr))
            }
        }
    }
    
    fn parse_expression(&mut self) -> Result<Expression, ParseError> {
        self.parse_logical_or()
    }
    
    fn parse_logical_or(&mut self) -> Result<Expression, ParseError> {
        let mut left = self.parse_logical_and()?;
        
        while matches!(self.peek(), Some(Token::Or)) {
            self.advance();
            let right = self.parse_logical_and()?;
            left = Expression::Binary(BinaryOp::Or, Box::new(left), Box::new(right));
        }
        
        Ok(left)
    }
    
    fn parse_logical_and(&mut self) -> Result<Expression, ParseError> {
        let mut left = self.parse_equality()?;
        
        while matches!(self.peek(), Some(Token::And)) {
            self.advance();
            let right = self.parse_equality()?;
            left = Expression::Binary(BinaryOp::And, Box::new(left), Box::new(right));
        }
        
        Ok(left)
    }
    
    fn parse_equality(&mut self) -> Result<Expression, ParseError> {
        let mut left = self.parse_relational()?;
        
        while let Some(token) = self.peek() {
            let op = match token {
                Token::Equal => BinaryOp::Equal,
                Token::NotEqual => BinaryOp::NotEqual,
                _ => break,
            };
            self.advance();
            let right = self.parse_relational()?;
            left = Expression::Binary(op, Box::new(left), Box::new(right));
        }
        
        Ok(left)
    }
    
    fn parse_relational(&mut self) -> Result<Expression, ParseError> {
        let mut left = self.parse_additive()?;
        
        while let Some(token) = self.peek() {
            let op = match token {
                Token::Less => BinaryOp::Less,
                Token::Greater => BinaryOp::Greater,
                Token::LessEqual => BinaryOp::LessEqual,
                Token::GreaterEqual => BinaryOp::GreaterEqual,
                _ => break,
            };
            self.advance();
            let right = self.parse_additive()?;
            left = Expression::Binary(op, Box::new(left), Box::new(right));
        }
        
        Ok(left)
    }
    
    fn parse_additive(&mut self) -> Result<Expression, ParseError> {
        let mut left = self.parse_multiplicative()?;
        
        while let Some(token) = self.peek() {
            let op = match token {
                Token::Plus => BinaryOp::Add,
                Token::Minus => BinaryOp::Sub,
                _ => break,
            };
            self.advance();
            let right = self.parse_multiplicative()?;
            left = Expression::Binary(op, Box::new(left), Box::new(right));
        }
        
        Ok(left)
    }
    
    fn parse_multiplicative(&mut self) -> Result<Expression, ParseError> {
        let mut left = self.parse_unary()?;
        
        while let Some(token) = self.peek() {
            let op = match token {
                Token::Star => BinaryOp::Mul,
                Token::Slash => BinaryOp::Div,
                Token::Percent => BinaryOp::Mod,
                _ => break,
            };
            self.advance();
            let right = self.parse_unary()?;
            left = Expression::Binary(op, Box::new(left), Box::new(right));
        }
        
        Ok(left)
    }
    
    fn parse_unary(&mut self) -> Result<Expression, ParseError> {
        match self.peek() {
            Some(Token::Not) => {
                self.advance();
                let expr = self.parse_unary()?;
                Ok(Expression::Unary(UnaryOp::Not, Box::new(expr)))
            }
            Some(Token::Minus) => {
                self.advance();
                let expr = self.parse_unary()?;
                Ok(Expression::Unary(UnaryOp::Neg, Box::new(expr)))
            }
            _ => self.parse_postfix(),
        }
    }
    
    fn parse_postfix(&mut self) -> Result<Expression, ParseError> {
        let mut expr = self.parse_primary()?;
        
        loop {
            match self.peek() {
                Some(Token::Dot) => {
                    self.advance();
                    let member = self.parse_identifier()?;
                    expr = Expression::MemberAccess(Box::new(expr), member);
                }
                Some(Token::LeftBracket) => {
                    self.advance();
                    let index = self.parse_expression()?;
                    self.expect(Token::RightBracket)?;
                    expr = Expression::ArrayAccess(Box::new(expr), Box::new(index));
                }
                Some(Token::LeftParen) => {
                    // 函数调用
                    if let Expression::Identifier(name) = expr {
                        self.advance();
                        let mut arguments = Vec::new();
                        
                        if !matches!(self.peek(), Some(Token::RightParen)) {
                            loop {
                                arguments.push(self.parse_expression()?);
                                if matches!(self.peek(), Some(Token::Comma)) {
                                    self.advance();
                                } else {
                                    break;
                                }
                            }
                        }
                        
                        self.expect(Token::RightParen)?;
                        expr = Expression::FunctionCall(name, arguments);
                    } else {
                        break;
                    }
                }
                Some(Token::As) => {
                    self.advance();
                    let target_type = self.parse_type_annotation()?;
                    expr = Expression::Cast(Box::new(expr), target_type);
                }
                _ => break,
            }
        }
        
        Ok(expr)
    }
    
    fn parse_primary(&mut self) -> Result<Expression, ParseError> {
        match self.peek() {
            Some(Token::Integer(n)) => {
                let value = *n;
                self.advance();
                Ok(Expression::Integer(value))
            }
            Some(Token::HexNumber(s)) => {
                // 检查是否是GNACS编码（48位十六进制）
                let value = s.clone();
                self.advance();
                if value.len() == 26 { // 0x + 24位十六进制 = 48位bit
                    Ok(Expression::GNACSCode(value))
                } else {
                    Ok(Expression::HexNumber(value))
                }
            }
            Some(Token::StringLiteral(s)) => {
                let value = s.clone();
                self.advance();
                Ok(Expression::String(value))
            }
            Some(Token::True) => {
                self.advance();
                Ok(Expression::Boolean(true))
            }
            Some(Token::False) => {
                self.advance();
                Ok(Expression::Boolean(false))
            }
            Some(Token::DIDLiteral(s)) => {
                let value = s.clone();
                self.advance();
                Ok(Expression::DID(value))
            }
            Some(Token::If) => {
                self.advance();
                let condition = self.parse_expression()?;
                self.expect(Token::LeftBrace)?;
                let then_expr = self.parse_expression()?;
                self.expect(Token::RightBrace)?;
                self.expect(Token::Else)?;
                self.expect(Token::LeftBrace)?;
                let else_expr = self.parse_expression()?;
                self.expect(Token::RightBrace)?;
                Ok(Expression::If(Box::new(condition), Box::new(then_expr), Box::new(else_expr)))
            }
            Some(Token::Require) => {
                self.advance();
                Ok(Expression::Identifier("require".to_string()))
            }
            Some(Token::Identifier(s)) => {
                let name = s.clone();
                self.advance();
                Ok(Expression::Identifier(name))
            }
            Some(Token::LeftParen) => {
                self.advance();
                let expr = self.parse_expression()?;
                self.expect(Token::RightParen)?;
                Ok(expr)
            }
            _ => {
                // 提供更详细的错误信息
                Err(ParseError::InvalidExpression)
            }
        }
    }
    
    fn parse_identifier(&mut self) -> Result<String, ParseError> {
        if let Some(Token::Identifier(s)) = self.peek() {
            let name = s.clone();
            self.advance();
            Ok(name)
        } else {
            Err(ParseError::UnexpectedToken {
                expected: "identifier".to_string(),
                actual: format!("{:?}", self.peek()),
            })
        }
    }
    
    fn parse_string_literal(&mut self) -> Result<String, ParseError> {
        if let Some(Token::StringLiteral(s)) = self.peek() {
            let value = s.clone();
            self.advance();
            Ok(value)
        } else {
            Err(ParseError::UnexpectedToken {
                expected: "string literal".to_string(),
                actual: format!("{:?}", self.peek()),
            })
        }
    }
    
    fn parse_hex_number(&mut self) -> Result<String, ParseError> {
        if let Some(Token::HexNumber(s)) = self.peek() {
            let value = s.clone();
            self.advance();
            Ok(value)
        } else {
            Err(ParseError::UnexpectedToken {
                expected: "hex number".to_string(),
                actual: format!("{:?}", self.peek()),
            })
        }
    }
}

/// 解析Token流为AST
pub fn parse(tokens: &[Token]) -> anyhow::Result<Program> {
    let mut parser = Parser::new(tokens.to_vec());
    Ok(parser.parse_program()?)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::lexer::tokenize;
    
    #[test]
    fn test_parse_empty() {
        let tokens = vec![];
        let program = parse(&tokens).unwrap();
        assert_eq!(program.items.len(), 0);
    }
    
    #[test]
    fn test_parse_module() {
        let source = "module test;";
        let tokens = tokenize(source).unwrap();
        let program = parse(&tokens).unwrap();
        
        assert_eq!(program.items.len(), 1);
        assert!(matches!(program.items[0], TopLevelItem::Module(_)));
    }
    
    #[test]
    fn test_parse_asset() {
        let source = r#"
            asset TestAsset {
                gnacs: 0x940101120187;
                sovereignty: C2;
                owner: DID;
                amount: uint256;
            }
        "#;
        
        let tokens = tokenize(source).unwrap();
        let program = parse(&tokens).unwrap();
        
        assert_eq!(program.items.len(), 1);
        if let TopLevelItem::Asset(asset) = &program.items[0] {
            assert_eq!(asset.name, "TestAsset");
            // 验证GNACS编码（使用to_hex方法）
            assert_eq!(asset.gnacs_code.to_hex(), "940101120187");
            assert!(matches!(asset.sovereignty, Some(SovereigntyType::C2)));
            assert_eq!(asset.fields.len(), 2);
        } else {
            panic!("Expected asset definition");
        }
    }
}