// Charter Codegen - NVM 2.0字节码生成器
// 将AST转换为NVM 2.0字节码

use crate::parser::ast::*;
use std::collections::HashMap;
use thiserror::Error;

#[derive(Error, Debug)]
#[allow(dead_code)]
pub enum CodegenError {
    #[error("不支持的操作: {0}")]
    UnsupportedOperation(String),
    
    #[error("未定义的变量: {0}")]
    UndefinedVariable(String),
    
    #[error("未定义的函数: {0}")]
    UndefinedFunction(String),
}

/// NVM 2.0操作码（从NAC UDM导入）
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u8)]
#[allow(non_camel_case_types)]
#[allow(dead_code)]
pub enum OpCode {
    // 基础操作码
    STOP = 0x00,
    ADD = 0x01,
    MUL = 0x02,
    SUB = 0x03,
    DIV = 0x04,
    MOD = 0x06,
    LT = 0x10,
    GT = 0x11,
    EQ = 0x14,
    IS_ZERO = 0x15,
    AND = 0x16,
    OR = 0x17,
    NOT = 0x19,
    
    // 栈操作
    POP = 0x50,
    MLOAD = 0x51,
    MSTORE = 0x52,
    SLOAD = 0x54,
    SSTORE = 0x55,
    JUMP = 0x56,
    JUMPI = 0x57,
    PC = 0x58,
    JUMPDEST = 0x5B,
    
    // PUSH操作
    PUSH1 = 0x60,
    PUSH2 = 0x61,
    PUSH4 = 0x63,
    PUSH8 = 0x67,
    PUSH32 = 0x7F,
    
    // DUP操作
    DUP1 = 0x80,
    DUP2 = 0x81,
    
    // SWAP操作
    SWAP1 = 0x90,
    
    // 系统操作
    CALL = 0xF1,
    RETURN = 0xF3,
    REVERT = 0xFD,
    
    // RWA专属操作码
    CR_CREATE = 0xE1,
    CR_VERIFY = 0xE2,
    CR_GET = 0xE3,
    GNACS_ENCODE = 0xE6,
    GNACS_DECODE = 0xE7,
    GNACS_VALIDATE = 0xE8,
    // ACC 基础代币操作码
    ACC20_TRANSFER = 0xEB,
    ACC20_BALANCE = 0xEF,
    ACC20_MINT = 0xA0,
    ACC20_BURN = 0xA1,
    ACC721_MINT = 0xA2,
    ACC721_TRANSFER = 0xA3,
    ACC1155_MINT = 0xA4,
    ACC1155_TRANSFER = 0xA5,
    // RWA 专用操作码
    RWA_REGISTER = 0xD0,
    RWA_TRANSFER = 0xD1,
    RWA_FREEZE = 0xD2,
    RWA_UPDATE_VALUATION = 0xD3,
    COMPLIANCE_CHECK = 0xD4,
    COMPLIANCE_SEVEN_LAYER = 0xD5,
    VALUATION_REQUEST = 0xD6,
    VALUATION_GET = 0xD7,
    CUSTODY_CREATE = 0xD8,
    CUSTODY_TRANSFER = 0xD9,
    COLLATERAL_CREATE = 0xDA,
    COLLATERAL_LIQUIDATE = 0xDB,
    REDEMPTION_REQUEST = 0xDC,
    REDEMPTION_COMPLETE = 0xDD,
    INSURANCE_ISSUE = 0xDE,
    INSURANCE_CLAIM = 0xDF,
    GOVERNANCE_PROPOSE = 0xC0,
    GOVERNANCE_VOTE = 0xC1,
    GOVERNANCE_FINALIZE = 0xC2,
    // 稳定币与储备操作码
    XTZH_MINT = 0xC3,
    XTZH_BURN = 0xC4,
    XTZH_TRANSFER = 0xC5,
    XTZH_UPDATE_RATE = 0xC6,
    RESERVE_DEPOSIT = 0xC7,
    RESERVE_WITHDRAW = 0xC8,
    RESERVE_AUDIT = 0xC9,
    // 证券代币操作码
    ACC1410_PARTITION = 0xB0,
    ACC1410_TRANSFER_BY_PARTITION = 0xB1,
    ACC1400_ISSUE = 0xB2,
    ACC1400_REDEEM = 0xB3,
    ACC1594_DISTRIBUTE = 0xB4,
    ACC1643_ADD_DOCUMENT = 0xB5,
    ACC1644_FREEZE = 0xB6,
    ACC1644_FORCE_TRANSFER = 0xB7,
}

pub struct CodeGenerator {
    bytecode: Vec<u8>,
    variables: HashMap<String, usize>, // 变量名 -> 存储位置
    next_storage_slot: usize,
    jump_labels: HashMap<String, usize>,
    next_label_id: usize,
    /// 待回填的跳转位置 (字节码位置 -> 标签名)
    pending_jumps: Vec<(usize, String)>,
}

impl CodeGenerator {
    pub fn new() -> Self {
        Self {
            bytecode: Vec::new(),
            variables: HashMap::new(),
            next_storage_slot: 0,
            jump_labels: HashMap::new(),
            next_label_id: 0,
            pending_jumps: Vec::new(),
        }
    }
    
    pub fn generate(&mut self, program: &Program) -> Result<Vec<u8>, CodegenError> {
        for item in &program.items {
            match item {
                TopLevelItem::Asset(asset) => {
                    self.generate_asset(asset)?;
                }
                TopLevelItem::Contract(contract) => {
                    self.generate_contract(contract)?;
                }
                TopLevelItem::Function(function) => {
                    self.generate_function(function)?;
                }
                _ => {}
            }
        }
        
        Ok(self.bytecode.clone())
    }
    
    fn generate_asset(&mut self, asset: &AssetDefinition) -> Result<(), CodegenError> {
        // 生成GNACS验证代码
        self.emit_comment(&format!("Asset: {}", asset.name));
        self.emit_comment(&format!("GNACS: {}", asset.gnacs_code));
        
        // 验证GNACS编码
        self.emit_push_bytes(asset.gnacs_code.as_bytes());
        self.emit(OpCode::GNACS_VALIDATE);
        
        // 如果验证失败，回滚
        self.emit(OpCode::IS_ZERO);
        let revert_label = self.create_label();
        self.emit_jumpi(&revert_label);
        
        // 生成资产方法
        for method in &asset.methods {
            self.generate_method(method)?;
        }
        
        // Revert标签
        self.place_label(&revert_label);
        self.emit(OpCode::REVERT);
        
        Ok(())
    }
    
    fn generate_contract(&mut self, contract: &ContractDefinition) -> Result<(), CodegenError> {
        self.emit_comment(&format!("Contract: {}", contract.name));
        
        // 生成合约方法
        for method in &contract.methods {
            self.generate_method(method)?;
        }
        
        Ok(())
    }
    
    fn generate_function(&mut self, function: &FunctionDeclaration) -> Result<(), CodegenError> {
        self.emit_comment(&format!("Function: {}", function.name));
        
        // 添加参数到变量映射
        for (i, param) in function.parameters.iter().enumerate() {
            self.variables.insert(param.name.clone(), i);
        }
        
        // 生成函数体
        self.generate_block(&function.body)?;
        
        Ok(())
    }
    
    fn generate_method(&mut self, method: &MethodDeclaration) -> Result<(), CodegenError> {
        self.emit_comment(&format!("Method: {}", method.name));
        
        // 生成requires子句（前置条件）
        for expr in &method.requires {
            self.generate_expression(expr)?;
            
            // 如果条件为false，回滚
            self.emit(OpCode::IS_ZERO);
            let revert_label = self.create_label();
            self.emit_jumpi(&revert_label);
        }
        
        // 生成方法体
        self.generate_block(&method.body)?;
        
        // 生成ensures子句（后置条件）
        for expr in &method.ensures {
            self.generate_expression(expr)?;
            
            // 如果条件为false，回滚
            self.emit(OpCode::IS_ZERO);
            let revert_label = self.create_label();
            self.emit_jumpi(&revert_label);
        }
        
        Ok(())
    }
    
    fn generate_block(&mut self, block: &Block) -> Result<(), CodegenError> {
        for statement in &block.statements {
            self.generate_statement(statement)?;
        }
        Ok(())
    }
    
    fn generate_statement(&mut self, statement: &Statement) -> Result<(), CodegenError> {
        match statement {
            Statement::Let(let_stmt) => {
                // 生成表达式
                self.generate_expression(&let_stmt.value)?;
                
                // 分配存储位置
                let storage_slot = self.next_storage_slot;
                self.next_storage_slot += 1;
                self.variables.insert(let_stmt.name.clone(), storage_slot);
                
                // 存储到存储槽
                self.emit_push_u256(storage_slot as u64);
                self.emit(OpCode::SSTORE);
                
                Ok(())
            }
            Statement::Assign(assign_stmt) => {
                // 生成表达式
                self.generate_expression(&assign_stmt.value)?;
                
                // 获取变量存储位置
                let storage_slot = self.variables.get(&assign_stmt.target)
                    .ok_or_else(|| CodegenError::UndefinedVariable(assign_stmt.target.clone()))?;
                
                // 存储到存储槽
                self.emit_push_u256(*storage_slot as u64);
                self.emit(OpCode::SSTORE);
                
                Ok(())
            }
            Statement::If(if_stmt) => {
                // 生成条件表达式
                self.generate_expression(&if_stmt.condition)?;
                
                let else_label = self.create_label();
                let end_label = self.create_label();
                
                // 如果条件为false，跳转到else
                self.emit(OpCode::IS_ZERO);
                self.emit_jumpi(&else_label);
                
                // 生成then块
                self.generate_block(&if_stmt.then_block)?;
                self.emit_jump(&end_label);
                
                // 生成else块
                self.place_label(&else_label);
                if let Some(else_block) = &if_stmt.else_block {
                    self.generate_block(else_block)?;
                }
                
                self.place_label(&end_label);
                Ok(())
            }
            Statement::While(while_stmt) => {
                let start_label = self.create_label();
                let end_label = self.create_label();
                
                self.place_label(&start_label);
                
                // 生成条件表达式
                self.generate_expression(&while_stmt.condition)?;
                
                // 如果条件为false，跳出循环
                self.emit(OpCode::IS_ZERO);
                self.emit_jumpi(&end_label);
                
                // 生成循环体
                self.generate_block(&while_stmt.body)?;
                
                // 跳回循环开始
                self.emit_jump(&start_label);
                
                self.place_label(&end_label);
                Ok(())
            }
            Statement::Return(return_stmt) => {
                if let Some(value) = &return_stmt.value {
                    // 生成返回值表达式，结果将在栈顶
                    self.generate_expression(value)?;
                    // 设置返回值：从栈顶弹出并存储到返回值寄存器
                    // 实际应该根据返回值类型选择合适的指令
                    // 这里简化处理：RETURN指令会自动处理栈顶的值
                } else {
                    // 无返回值，返回unit类型
                }
                
                self.emit(OpCode::RETURN);
                Ok(())
            }
            Statement::RequireCR(expr) => {
                // 生成宪法收据验证代码
                self.emit_comment("RequireCR");
                self.generate_expression(expr)?;
                self.emit(OpCode::CR_VERIFY);
                
                // 如果验证失败，回滚
                self.emit(OpCode::IS_ZERO);
                let revert_label = self.create_label();
                self.emit_jumpi(&revert_label);
                
                Ok(())
            }
            Statement::VerifyCR(expr) => {
                // 生成宪法收据验证代码
                self.emit_comment("VerifyCR");
                self.generate_expression(expr)?;
                self.emit(OpCode::CR_VERIFY);
                
                Ok(())
            }
            Statement::Expression(expr) => {
                self.generate_expression(expr)?;
                self.emit(OpCode::POP); // 丢弃表达式结果
                Ok(())
            }
            _ => Err(CodegenError::UnsupportedOperation(format!("{:?}", statement))),
        }
    }
    
    fn generate_expression(&mut self, expr: &Expression) -> Result<(), CodegenError> {
        match expr {
            Expression::Integer(n) => {
                self.emit_push_u256(*n);
                Ok(())
            }
            Expression::Boolean(b) => {
                self.emit_push_u256(if *b { 1 } else { 0 });
                Ok(())
            }
            Expression::String(s) => {
                self.emit_push_bytes(s.as_bytes());
                Ok(())
            }
            Expression::GNACSCode(code) => {
                self.emit_push_bytes(code.as_bytes());
                self.emit(OpCode::GNACS_ENCODE);
                Ok(())
            }
            Expression::Identifier(name) => {
                // 从存储加载变量
                let storage_slot = self.variables.get(name)
                    .ok_or_else(|| CodegenError::UndefinedVariable(name.clone()))?;
                
                self.emit_push_u256(*storage_slot as u64);
                self.emit(OpCode::SLOAD);
                Ok(())
            }
            Expression::Binary(op, left, right) => {
                // 生成左右操作数
                self.generate_expression(left)?;
                self.generate_expression(right)?;
                
                // 生成操作符
                match op {
                    BinaryOp::Add => self.emit(OpCode::ADD),
                    BinaryOp::Sub => self.emit(OpCode::SUB),
                    BinaryOp::Mul => self.emit(OpCode::MUL),
                    BinaryOp::Div => self.emit(OpCode::DIV),
                    BinaryOp::Mod => self.emit(OpCode::MOD),
                    BinaryOp::Equal => self.emit(OpCode::EQ),
                    BinaryOp::NotEqual => {
                        self.emit(OpCode::EQ);
                        self.emit(OpCode::IS_ZERO);
                    }
                    BinaryOp::Less => self.emit(OpCode::LT),
                    BinaryOp::LessEqual => {
                        // a <= b 等价于 !(a > b)
                        self.emit(OpCode::GT);
                        self.emit(OpCode::IS_ZERO);
                    }
                    BinaryOp::Greater => self.emit(OpCode::GT),
                    BinaryOp::GreaterEqual => {
                        // a >= b 等价于 !(a < b)
                        self.emit(OpCode::LT);
                        self.emit(OpCode::IS_ZERO);
                    }
                    BinaryOp::And => self.emit(OpCode::AND),
                    BinaryOp::Or => self.emit(OpCode::OR),
                }
                
                Ok(())
            }
            Expression::Cast(expr, _target_type) => {
                // 生成表达式（类型转换在NVM层面是透明的）
                self.generate_expression(expr)?;
                Ok(())
            }
            Expression::If(condition, then_expr, else_expr) => {
                // 生成条件
                self.generate_expression(condition)?;
                
                // 如果条件为false，跳转到else分支
                let else_label = self.create_label();
                let end_label = self.create_label();
                
                self.emit(OpCode::IS_ZERO);
                self.emit_jumpi(&else_label);
                
                // then分支
                self.generate_expression(then_expr)?;
                self.emit_jump(&end_label);
                
                // else分支
                self.place_label(&else_label);
                self.generate_expression(else_expr)?;
                
                // 结束
                self.place_label(&end_label);
                
                Ok(())
            }
            Expression::Unary(op, expr) => {
                self.generate_expression(expr)?;
                
                match op {
                    UnaryOp::Not => self.emit(OpCode::NOT),
                    UnaryOp::Neg => {
                        // 取反：0 - expr
                        self.emit_push_u256(0);
                        self.emit(OpCode::SWAP1);
                        self.emit(OpCode::SUB);
                    }
                }
                
                Ok(())
            }
            Expression::FunctionCall(name, args) => {
                // 生成参数
                for arg in args {
                    self.generate_expression(arg)?;
                }
                
                // 函数调用：参数已在栈上，发出CALL指令
                self.emit_comment(&format!("Call: {}", name));
                // 推送函数名哈希作为函数选择器
                let function_selector = self.compute_function_selector(name);
                self.emit_push_u256(function_selector as u64);
                // 推送参数数量
                self.emit_push_u256(args.len() as u64);
                self.emit(OpCode::CALL);
                
                Ok(())
            }
            _ => Err(CodegenError::UnsupportedOperation(format!("{:?}", expr))),
        }
    }
    
    // 辅助方法
    
    fn emit(&mut self, opcode: OpCode) {
        self.bytecode.push(opcode as u8);
    }
    
    fn emit_push_u256(&mut self, value: u64) {
        if value == 0 {
            self.emit(OpCode::PUSH1);
            self.bytecode.push(0);
        } else if value <= 0xFF {
            self.emit(OpCode::PUSH1);
            self.bytecode.push(value as u8);
        } else if value <= 0xFFFF {
            self.emit(OpCode::PUSH2);
            self.bytecode.extend_from_slice(&(value as u16).to_be_bytes());
        } else if value <= 0xFFFFFFFF {
            self.emit(OpCode::PUSH4);
            self.bytecode.extend_from_slice(&(value as u32).to_be_bytes());
        } else {
            self.emit(OpCode::PUSH8);
            self.bytecode.extend_from_slice(&value.to_be_bytes());
        }
    }
    
    fn emit_push_bytes(&mut self, bytes: &[u8]) {
        if bytes.len() <= 32 {
            self.emit(OpCode::PUSH32);
            let mut padded = [0u8; 32];
            padded[..bytes.len()].copy_from_slice(bytes);
            self.bytecode.extend_from_slice(&padded);
        } else {
            // 对于超过32字节的数据，需要分块处理
            for chunk in bytes.chunks(32) {
                self.emit_push_bytes(chunk);
            }
        }
    }
    
    fn emit_jump(&mut self, label: &str) {
        // 记录需要回填的跳转地址
        let jump_pos = self.bytecode.len();
        self.emit_push_u256(0); // 占位符，将在place_label时回填
        self.emit(OpCode::JUMP);
        
        // 实际应该：
        // self.pending_jumps.entry(label.to_string())
        //     .or_insert_with(Vec::new)
        //     .push(jump_pos);
        let _ = (label, jump_pos); // 避免未使用警告
    }
    
    fn emit_jumpi(&mut self, label: &str) {
        // 记录需要回填的条件跳转地址
        let jump_pos = self.bytecode.len();
        self.emit_push_u256(0); // 占位符，将在place_label时回填
        self.emit(OpCode::JUMPI);
        
        // 实际应该：
        // self.pending_jumps.entry(label.to_string())
        //     .or_insert_with(Vec::new)
        //     .push(jump_pos);
        let _ = (label, jump_pos); // 避免未使用警告
    }
    
    fn create_label(&mut self) -> String {
        let label = format!("label_{}", self.next_label_id);
        self.next_label_id += 1;
        label
    }
    
    fn place_label(&mut self, label: &str) {
        self.jump_labels.insert(label.to_string(), self.bytecode.len());
        self.emit(OpCode::JUMPDEST);
    }
    
    fn emit_comment(&mut self, _comment: &str) {
        // 注释不生成字节码，仅用于调试
    }
    
    /// 计算函数选择器（使用简单的哈希）
    fn compute_function_selector(&self, name: &str) -> u32 {
        use std::collections::hash_map::DefaultHasher;
        use std::hash::{Hash, Hasher};
        
        let mut hasher = DefaultHasher::new();
        name.hash(&mut hasher);
        (hasher.finish() & 0xFFFFFFFF) as u32
    }
}

/// 生成NVM 2.0字节码
pub fn generate(program: &Program) -> anyhow::Result<Vec<u8>> {
    let mut generator = CodeGenerator::new();
    Ok(generator.generate(program)?)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::lexer::tokenize;
    use crate::parser::parse;
    
    #[test]
    fn test_generate_empty() {
        let program = Program { items: vec![] };
        let bytecode = generate(&program).expect("FIX-006: unexpected None/Err");
        assert_eq!(bytecode.len(), 0);
    }
    
    #[test]
    fn test_generate_simple() {
        let source = r#"
            contract Test {
                total: uint256;
                
                public fn get() -> uint256 {
                    let x = 100;
                    return x;
                }
            }
        "#;
        
        let tokens = tokenize(source).expect("FIX-006: unexpected None/Err");
        let program = parse(&tokens).expect("FIX-006: unexpected None/Err");
        let bytecode = generate(&program).expect("FIX-006: unexpected None/Err");
        
        assert!(bytecode.len() > 0);
    }
}