// tools/build/build-shaders.ts
import * as fs from 'fs';
import * as path from 'path';
import * as yaml from 'yaml';
import { glob } from 'fast-glob';
import chalk from 'chalk';

interface ShaderBuildConfig {
    inputDir: string;
    outputDir: string;
    optimization: boolean;
    validation: boolean;
    platforms: string[];
    profiles: BuildProfile[];
}

interface BuildProfile {
    name: string;
    target: 'webgl1' | 'webgl2' | 'mobile' | 'desktop';
    optimization: OptimizationSettings;
    defines: Record<string, any>;
}

interface OptimizationSettings {
    minify: boolean;
    stripComments: boolean;
    inlineIncludes: boolean;
    optimizeConstants: boolean;
    removeUnusedCode: boolean;
}

class ShaderBuilder {
    private config: ShaderBuildConfig;
    private includeCache: Map<string, string> = new Map();
    
    constructor(configPath: string) {
        this.config = this.loadConfig(configPath);
    }
    
    private loadConfig(configPath: string): ShaderBuildConfig {
        const configContent = fs.readFileSync(configPath, 'utf-8');
        return yaml.parse(configContent) as ShaderBuildConfig;
    }
    
    public async build(): Promise<void> {
        console.log(chalk.blue('🚀 开始构建着色器...'));
        
        try {
            // 清理输出目录
            await this.cleanOutputDir();
            
            // 扫描着色器文件
            const shaderFiles = await this.scanShaderFiles();
            console.log(chalk.green(`📂 发现 ${shaderFiles.length} 个着色器文件`));
            
            // 为每个构建配置文件构�?            for (const profile of this.config.profiles) {
                await this.buildProfile(profile, shaderFiles);
            }
            
            console.log(chalk.green('�?着色器构建完成'));
        } catch (error) {
            console.error(chalk.red('�?构建失败:'), error);
            process.exit(1);
        }
    }
    
    private async cleanOutputDir(): Promise<void> {
        if (fs.existsSync(this.config.outputDir)) {
            fs.rmSync(this.config.outputDir, { recursive: true, force: true });
        }
        fs.mkdirSync(this.config.outputDir, { recursive: true });
    }
    
    private async scanShaderFiles(): Promise<string[]> {
        const patterns = [
            `${this.config.inputDir}/**/*.effect`,
            `${this.config.inputDir}/**/*.chunk`
        ];
        
        return await glob(patterns, {
            ignore: ['**/node_modules/**', '**/temp/**', '**/.*/**']
        });
    }
    
    private async buildProfile(profile: BuildProfile, shaderFiles: string[]): Promise<void> {
        console.log(chalk.yellow(`📦 构建配置: ${profile.name}`));
        
        const outputDir = path.join(this.config.outputDir, profile.name);
        fs.mkdirSync(outputDir, { recursive: true });
        
        for (const filePath of shaderFiles) {
            try {
                await this.processShaderFile(filePath, profile, outputDir);
            } catch (error) {
                console.error(chalk.red(`�?处理文件失败 ${filePath}:`), error);
                throw error;
            }
        }
    }
    
    private async processShaderFile(filePath: string, profile: BuildProfile, outputDir: string): Promise<void> {
        const content = fs.readFileSync(filePath, 'utf-8');
        let processedContent = content;
        
        // 应用预处理器定义
        processedContent = this.applyDefines(processedContent, profile.defines);
        
        // 内联Include文件
        if (profile.optimization.inlineIncludes) {
            processedContent = await this.inlineIncludes(processedContent);
        }
        
        // 优化着色器代码
        if (profile.optimization.optimizeConstants) {
            processedContent = this.optimizeConstants(processedContent);
        }
        
        // 移除未使用的代码
        if (profile.optimization.removeUnusedCode) {
            processedContent = this.removeUnusedCode(processedContent);
        }
        
        // 压缩代码
        if (profile.optimization.minify) {
            processedContent = this.minifyShader(processedContent);
        }
        
        // 移除注释
        if (profile.optimization.stripComments) {
            processedContent = this.stripComments(processedContent);
        }
        
        // 验证着色器
        if (this.config.validation) {
            await this.validateShader(processedContent, filePath);
        }
        
        // 写入输出文件
        const relativePath = path.relative(this.config.inputDir, filePath);
        const outputPath = path.join(outputDir, relativePath);
        
        fs.mkdirSync(path.dirname(outputPath), { recursive: true });
        fs.writeFileSync(outputPath, processedContent);
        
        console.log(chalk.green(`  �?${relativePath}`));
    }
    
    private applyDefines(content: string, defines: Record<string, any>): string {
        let result = content;
        
        for (const [key, value] of Object.entries(defines)) {
            const definePattern = new RegExp(`#pragma\\s+define\\s+${key}\\s+.*`, 'g');
            result = result.replace(definePattern, `#define ${key} ${value}`);
        }
        
        return result;
    }
    
    private async inlineIncludes(content: string): Promise<string> {
        const includePattern = /#include\s+<([^>]+)>/g;
        let result = content;
        let match;
        
        while ((match = includePattern.exec(content)) !== null) {
            const includePath = match[1];
            const includeContent = await this.loadIncludeFile(includePath);
            
            result = result.replace(match[0], includeContent);
        }
        
        return result;
    }
    
    private async loadIncludeFile(includePath: string): Promise<string> {
        if (this.includeCache.has(includePath)) {
            return this.includeCache.get(includePath)!;
        }
        
        const fullPath = path.join(this.config.inputDir, 'common/includes', includePath);
        
        if (!fs.existsSync(fullPath)) {
            throw new Error(`Include文件不存�? ${includePath}`);
        }
        
        const content = fs.readFileSync(fullPath, 'utf-8');
        this.includeCache.set(includePath, content);
        
        return content;
    }
    
    private optimizeConstants(content: string): string {
        // 常量折叠优化
        let result = content;
        
        // 简单的数学常量折叠
        result = result.replace(/(\d+\.\d+)\s*\+\s*(\d+\.\d+)/g, (match, a, b) => {
            return (parseFloat(a) + parseFloat(b)).toString();
        });
        
        result = result.replace(/(\d+\.\d+)\s*\*\s*(\d+\.\d+)/g, (match, a, b) => {
            return (parseFloat(a) * parseFloat(b)).toString();
        });
        
        return result;
    }
    
    private removeUnusedCode(content: string): string {
        // 移除未使用的函数和变�?        // 这是一个简化的实现，实际需要更复杂的AST分析
        const lines = content.split('\n');
        const usedSymbols = new Set<string>();
        const definedSymbols = new Map<string, number>();
        
        // 第一遍：收集所有定义的符号
        lines.forEach((line, index) => {
            const functionMatch = line.match(/(?:float|vec2|vec3|vec4|mat3|mat4|bool|int)\s+(\w+)\s*\(/);
            if (functionMatch) {
                definedSymbols.set(functionMatch[1], index);
            }
            
            const variableMatch = line.match(/(?:uniform|varying|attribute)\s+\w+\s+(\w+);/);
            if (variableMatch) {
                definedSymbols.set(variableMatch[1], index);
            }
        });
        
        // 第二遍：收集使用的符�?        lines.forEach(line => {
            for (const symbol of definedSymbols.keys()) {
                if (line.includes(symbol) && !line.match(new RegExp(`\\b(?:float|vec2|vec3|vec4|mat3|mat4|bool|int)\\s+${symbol}\\s*[\\(;]`))) {
                    usedSymbols.add(symbol);
                }
            }
        });
        
        // 移除未使用的定义
        return lines.filter((line, index) => {
            for (const [symbol, defIndex] of definedSymbols.entries()) {
                if (defIndex === index && !usedSymbols.has(symbol)) {
                    return false;
                }
            }
            return true;
        }).join('\n');
    }
    
    private minifyShader(content: string): string {
        let result = content;
        
        // 移除多余的空白字�?        result = result.replace(/\s+/g, ' ');
        result = result.replace(/\s*([{}();,])\s*/g, '$1');
        result = result.replace(/^\s+|\s+$/gm, '');
        
        // 移除空行
        result = result.replace(/\n\s*\n/g, '\n');
        
        return result;
    }
    
    private stripComments(content: string): string {
        // 移除单行注释
        let result = content.replace(/\/\/.*$/gm, '');
        
        // 移除多行注释
        result = result.replace(/\/\*[\s\S]*?\*\//g, '');
        
        return result;
    }
    
    private async validateShader(content: string, filePath: string): Promise<void> {
        // 基本的语法验�?        const errors: string[] = [];
        
        // 检查括号匹�?        let braceCount = 0;
        let parenCount = 0;
        
        for (const char of content) {
            switch (char) {
                case '{': braceCount++; break;
                case '}': braceCount--; break;
                case '(': parenCount++; break;
                case ')': parenCount--; break;
            }
        }
        
        if (braceCount !== 0) {
            errors.push('大括号不匹配');
        }
        
        if (parenCount !== 0) {
            errors.push('小括号不匹配');
        }
        
        // 检查必需的函�?        if (!content.includes('void main()') && !content.includes('void vert()') && !content.includes('void frag()')) {
            errors.push('缺少主函�?);
        }
        
        if (errors.length > 0) {
            throw new Error(`着色器验证失败 ${filePath}: ${errors.join(', ')}`);
        }
    }
}

// 使用示例
if (require.main === module) {
    const builder = new ShaderBuilder('./tools/build/build-config.yaml');
    builder.build().catch(console.error);
}

// tools/validation/shader-test-framework.ts
import * as fs from 'fs';
import * as path from 'path';
import chalk from 'chalk';

interface TestCase {
    name: string;
    shaderPath: string;
    expectedOutput?: string;
    expectedErrors?: string[];
    timeout?: number;
    platform?: string;
    skipReason?: string;
}

interface TestResult {
    testCase: TestCase;
    passed: boolean;
    error?: string;
    duration: number;
    output?: any;
}

interface TestSuite {
    name: string;
    description: string;
    testCases: TestCase[];
    setup?: () => Promise<void>;
    teardown?: () => Promise<void>;
}

class ShaderTestRunner {
    private testSuites: TestSuite[] = [];
    private results: TestResult[] = [];
    
    public addTestSuite(suite: TestSuite): void {
        this.testSuites.push(suite);
    }
    
    public async runAllTests(): Promise<TestReport> {
        console.log(chalk.blue('🧪 开始运行着色器测试...'));
        
        const startTime = Date.now();
        this.results = [];
        
        for (const suite of this.testSuites) {
            await this.runTestSuite(suite);
        }
        
        const endTime = Date.now();
        const duration = endTime - startTime;
        
        return this.generateReport(duration);
    }
    
    private async runTestSuite(suite: TestSuite): Promise<void> {
        console.log(chalk.yellow(`📁 测试套件: ${suite.name}`));
        
        // 执行设置
        if (suite.setup) {
            await suite.setup();
        }
        
        try {
            for (const testCase of suite.testCases) {
                const result = await this.runTestCase(testCase);
                this.results.push(result);
                
                const status = result.passed ? chalk.green('�?) : chalk.red('�?);
                const duration = chalk.gray(`(${result.duration}ms)`);
                console.log(`  ${status} ${testCase.name} ${duration}`);
                
                if (!result.passed && result.error) {
                    console.log(chalk.red(`    错误: ${result.error}`));
                }
            }
        } finally {
            // 执行清理
            if (suite.teardown) {
                await suite.teardown();
            }
        }
    }
    
    private async runTestCase(testCase: TestCase): Promise<TestResult> {
        const startTime = Date.now();
        
        try {
            // 检查是否应该跳�?            if (testCase.skipReason) {
                return {
                    testCase,
                    passed: true,
                    duration: 0
                };
            }
            
            // 运行测试
            const output = await this.executeTest(testCase);
            
            // 验证结果
            const passed = this.validateTestResult(testCase, output);
            
            return {
                testCase,
                passed,
                duration: Date.now() - startTime,
                output
            };
        } catch (error) {
            return {
                testCase,
                passed: false,
                error: error instanceof Error ? error.message : String(error),
                duration: Date.now() - startTime
            };
        }
    }
    
    private async executeTest(testCase: TestCase): Promise<any> {
        // 加载着色器文件
        const shaderContent = fs.readFileSync(testCase.shaderPath, 'utf-8');
        
        // 解析着色器
        const shader = this.parseShader(shaderContent);
        
        // 编译着色器
        const compilationResult = await this.compileShader(shader, testCase.platform);
        
        // 运行着色器（如果支持）
        const runtimeResult = await this.runShader(compilationResult);
        
        return {
            compilation: compilationResult,
            runtime: runtimeResult
        };
    }
    
    private parseShader(content: string): ParsedShader {
        // 解析CCEffect和CCProgram�?        const effectMatch = content.match(/CCEffect\s*%\{([\s\S]*?)\}%/);
        const programMatches = [...content.matchAll(/CCProgram\s+(\w+)\s*%\{([\s\S]*?)\}%/g)];
        
        return {
            effect: effectMatch ? effectMatch[1] : null,
            programs: programMatches.map(match => ({
                name: match[1],
                source: match[2]
            }))
        };
    }
    
    private async compileShader(shader: ParsedShader, platform?: string): Promise<CompilationResult> {
        const errors: string[] = [];
        const warnings: string[] = [];
        
        // 验证CCEffect语法
        if (shader.effect) {
            try {
                const yaml = require('yaml');
                yaml.parse(shader.effect);
            } catch (error) {
                errors.push(`CCEffect YAML语法错误: ${error.message}`);
            }
        }
        
        // 验证GLSL语法
        for (const program of shader.programs) {
            const glslErrors = this.validateGLSL(program.source);
            errors.push(...glslErrors);
        }
        
        return {
            success: errors.length === 0,
            errors,
            warnings,
            platform: platform || 'webgl2'
        };
    }
    
    private validateGLSL(source: string): string[] {
        const errors: string[] = [];
        
        // 基本语法检�?        let braceCount = 0;
        let parenCount = 0;
        
        for (const char of source) {
            switch (char) {
                case '{': braceCount++; break;
                case '}': braceCount--; break;
                case '(': parenCount++; break;
                case ')': parenCount--; break;
            }
        }
        
        if (braceCount !== 0) {
            errors.push('大括号不匹配');
        }
        
        if (parenCount !== 0) {
            errors.push('小括号不匹配');
        }
        
        // 检查必需的精度声�?        if (source.includes('float') && !source.includes('precision')) {
            errors.push('缺少精度声明');
        }
        
        return errors;
    }
    
    private async runShader(compilationResult: CompilationResult): Promise<RuntimeResult> {
        // 简化的运行时测�?        // 实际实现需要WebGL上下�?        return {
            executed: compilationResult.success,
            renderTime: compilationResult.success ? Math.random() * 16 : 0,
            memoryUsage: compilationResult.success ? Math.random() * 1024 : 0
        };
    }
    
    private validateTestResult(testCase: TestCase, output: any): boolean {
        // 检查编译是否成�?        if (!output.compilation.success) {
            // 如果期望有错误，检查错误是否匹�?            if (testCase.expectedErrors) {
                return testCase.expectedErrors.every(expectedError =>
                    output.compilation.errors.some((error: string) =>
                        error.includes(expectedError)
                    )
                );
            }
            return false;
        }
        
        // 如果期望有错误但编译成功，测试失�?        if (testCase.expectedErrors && testCase.expectedErrors.length > 0) {
            return false;
        }
        
        // 检查预期输�?        if (testCase.expectedOutput) {
            // 这里可以添加更复杂的输出验证逻辑
            return true;
        }
        
        return true;
    }
    
    private generateReport(duration: number): TestReport {
        const total = this.results.length;
        const passed = this.results.filter(r => r.passed).length;
        const failed = total - passed;
        const skipped = this.results.filter(r => r.testCase.skipReason).length;
        
        return {
            summary: {
                total,
                passed,
                failed,
                skipped,
                duration,
                passRate: total > 0 ? (passed / total) * 100 : 0
            },
            results: this.results,
            timestamp: new Date().toISOString()
        };
    }
}

interface ParsedShader {
    effect: string | null;
    programs: Array<{
        name: string;
        source: string;
    }>;
}

interface CompilationResult {
    success: boolean;
    errors: string[];
    warnings: string[];
    platform: string;
}

interface RuntimeResult {
    executed: boolean;
    renderTime: number;
    memoryUsage: number;
}

interface TestReport {
    summary: {
        total: number;
        passed: number;
        failed: number;
        skipped: number;
        duration: number;
        passRate: number;
    };
    results: TestResult[];
    timestamp: string;
}

// 预定义测试套�?export const basicShaderTests: TestSuite = {
    name: "基础着色器测试",
    description: "测试基本的着色器功能",
    testCases: [
        {
            name: "简单顶点着色器编译",
            shaderPath: "tests/fixtures/simple-vertex.effect"
        },
        {
            name: "简单片段着色器编译",
            shaderPath: "tests/fixtures/simple-fragment.effect"
        },
        {
            name: "Surface Shader编译",
            shaderPath: "tests/fixtures/simple-surface.effect"
        },
        {
            name: "语法错误检�?,
            shaderPath: "tests/fixtures/syntax-error.effect",
            expectedErrors: ["大括号不匹配"]
        }
    ]
};

export const performanceTests: TestSuite = {
    name: "性能测试",
    description: "测试着色器性能特征",
    testCases: [
        {
            name: "复杂片段着色器性能",
            shaderPath: "tests/fixtures/complex-fragment.effect",
            timeout: 5000
        },
        {
            name: "大量纹理采样性能",
            shaderPath: "tests/fixtures/many-textures.effect",
            timeout: 3000
        }
    ]
};