// src/extension.ts
import * as vscode from 'vscode';
import { CocosShaderLanguageProvider } from './languageProvider';
import { CocosShaderDiagnosticsProvider } from './diagnosticsProvider';
import { CocosShaderPreviewProvider } from './previewProvider';

export function activate(context: vscode.ExtensionContext) {
    console.log('🚀 Cocos Shader扩展已激活');
    
    // 注册语言服务提供者
    const languageProvider = new CocosShaderLanguageProvider();
    context.subscriptions.push(
        vscode.languages.registerCompletionItemProvider(
            { language: 'cocos-shader' },
            languageProvider,
            '.',
            '_',
            ':'
        )
    );
    
    // 注册诊断提供者
    const diagnosticsProvider = new CocosShaderDiagnosticsProvider();
    context.subscriptions.push(diagnosticsProvider);
    
    // 注册预览提供者
    const previewProvider = new CocosShaderPreviewProvider(context);
    context.subscriptions.push(
        vscode.window.registerWebviewViewProvider(
            'cocosShaderPreview',
            previewProvider
        )
    );
    
    // 注册命令
    registerCommands(context);
    
    // 监听文件变化
    setupFileWatchers(context);
}

class CocosShaderLanguageProvider implements vscode.CompletionItemProvider {
    private keywords: vscode.CompletionItem[] = [];
    private functions: vscode.CompletionItem[] = [];
    private types: vscode.CompletionItem[] = [];
    
    constructor() {
        this.initializeCompletions();
    }
    
    private initializeCompletions(): void {
        // GLSL关键字补全
        const glslKeywords = [
            'precision', 'highp', 'mediump', 'lowp',
            'in', 'out', 'inout', 'uniform', 'varying', 'attribute',
            'layout', 'location', 'binding',
            'if', 'else', 'for', 'while', 'do', 'break', 'continue', 'return', 'discard'
        ];
        
        this.keywords = glslKeywords.map(keyword => {
            const item = new vscode.CompletionItem(keyword, vscode.CompletionItemKind.Keyword);
            item.detail = `GLSL关键字`;
            return item;
        });
        
        // GLSL内置函数补全
        const glslFunctions = [
            { name: 'texture', detail: 'texture(sampler, coord)', doc: '纹理采样函数' },
            { name: 'normalize', detail: 'normalize(vec)', doc: '向量归一化' },
            { name: 'dot', detail: 'dot(vec1, vec2)', doc: '向量点积' },
            { name: 'cross', detail: 'cross(vec1, vec2)', doc: '向量叉积' },
            { name: 'mix', detail: 'mix(x, y, a)', doc: '线性插值' },
            { name: 'step', detail: 'step(edge, x)', doc: '阶跃函数' },
            { name: 'smoothstep', detail: 'smoothstep(edge0, edge1, x)', doc: '平滑阶跃函数' },
            { name: 'clamp', detail: 'clamp(x, minVal, maxVal)', doc: '值限制函数' },
            { name: 'pow', detail: 'pow(x, y)', doc: '幂函数' },
            { name: 'sin', detail: 'sin(angle)', doc: '正弦函数' },
            { name: 'cos', detail: 'cos(angle)', doc: '余弦函数' }
        ];
        
        this.functions = glslFunctions.map(func => {
            const item = new vscode.CompletionItem(func.name, vscode.CompletionItemKind.Function);
            item.detail = func.detail;
            item.documentation = new vscode.MarkdownString(func.doc);
            item.insertText = new vscode.SnippetString(`${func.name}($1)`);
            return item;
        });
        
        // GLSL类型补全
        const glslTypes = [
            'void', 'bool', 'int', 'uint', 'float',
            'vec2', 'vec3', 'vec4', 'bvec2', 'bvec3', 'bvec4',
            'ivec2', 'ivec3', 'ivec4', 'uvec2', 'uvec3', 'uvec4',
            'mat2', 'mat3', 'mat4',
            'sampler2D', 'samplerCube', 'sampler2DArray'
        ];
        
        this.types = glslTypes.map(type => {
            const item = new vscode.CompletionItem(type, vscode.CompletionItemKind.Class);
            item.detail = `GLSL数据类型`;
            return item;
        });
    }
    
    public provideCompletionItems(
        document: vscode.TextDocument,
        position: vscode.Position,
        token: vscode.CancellationToken,
        context: vscode.CompletionContext
    ): vscode.ProviderResult<vscode.CompletionItem[] | vscode.CompletionList> {
        const line = document.lineAt(position);
        const linePrefix = line.text.substr(0, position.character);
        
        // 检查是否在CCEffect块中
        if (this.isInCCEffectBlock(document, position)) {
            return this.provideCCEffectCompletions(linePrefix);
        }
        
        // 检查是否在CCProgram块中
        if (this.isInCCProgramBlock(document, position)) {
            return this.provideGLSLCompletions(linePrefix);
        }
        
        return [];
    }
    
    private isInCCEffectBlock(document: vscode.TextDocument, position: vscode.Position): boolean {
        // 检查是否在CCEffect %{ ... }%块中
        const text = document.getText(new vscode.Range(0, 0, position.line, position.character));
        const ccEffectStart = text.lastIndexOf('CCEffect %{');
        const ccEffectEnd = text.lastIndexOf('}%');
        
        return ccEffectStart > ccEffectEnd;
    }
    
    private isInCCProgramBlock(document: vscode.TextDocument, position: vscode.Position): boolean {
        // 检查是否在CCProgram %{ ... }%块中
        const text = document.getText(new vscode.Range(0, 0, position.line, position.character));
        const ccProgramStart = text.lastIndexOf('CCProgram');
        const ccProgramEnd = text.lastIndexOf('}%');
        
        return ccProgramStart > ccProgramEnd;
    }
    
    private provideCCEffectCompletions(linePrefix: string): vscode.CompletionItem[] {
        // CCEffect YAML配置补全
        const ccEffectItems = [
            this.createYamlCompletionItem('techniques', 'techniques:\n- name: ${1:technique-name}'),
            this.createYamlCompletionItem('passes', 'passes:\n- vert: ${1:vs}:vert\n  frag: ${2:fs}:frag'),
            this.createYamlCompletionItem('properties', 'properties:\n  ${1:property}: { value: ${2:value} }'),
            this.createYamlCompletionItem('rasterizerState', 'rasterizerState:\n  cullMode: ${1:back}'),
            this.createYamlCompletionItem('depthStencilState', 'depthStencilState:\n  depthTest: ${1:true}\n  depthWrite: ${2:true}'),
            this.createYamlCompletionItem('blendState', 'blendState:\n  targets:\n  - blend: ${1:true}')
        ];
        
        return ccEffectItems;
    }
    
    private provideGLSLCompletions(linePrefix: string): vscode.CompletionItem[] {
        return [...this.keywords, ...this.functions, ...this.types];
    }
    
    private createYamlCompletionItem(label: string, snippet: string): vscode.CompletionItem {
        const item = new vscode.CompletionItem(label, vscode.CompletionItemKind.Property);
        item.insertText = new vscode.SnippetString(snippet);
        item.detail = 'CCEffect配置';
        return item;
    }
}

class CocosShaderDiagnosticsProvider {
    private diagnosticCollection: vscode.DiagnosticCollection;
    
    constructor() {
        this.diagnosticCollection = vscode.languages.createDiagnosticCollection('cocos-shader');
        
        // 监听文档变化
        vscode.workspace.onDidSaveTextDocument(this.validateDocument, this);
        vscode.workspace.onDidOpenTextDocument(this.validateDocument, this);
        vscode.workspace.onDidChangeTextDocument(event => {
            this.validateDocument(event.document);
        });
    }
    
    private validateDocument(document: vscode.TextDocument): void {
        if (document.languageId !== 'cocos-shader') {
            return;
        }
        
        const diagnostics: vscode.Diagnostic[] = [];
        const text = document.getText();
        
        // 检查常见错误
        this.checkSyntaxErrors(document, text, diagnostics);
        this.checkBestPractices(document, text, diagnostics);
        
        this.diagnosticCollection.set(document.uri, diagnostics);
    }
    
    private checkSyntaxErrors(document: vscode.TextDocument, text: string, diagnostics: vscode.Diagnostic[]): void {
        // 检查CCEffect块语法
        const ccEffectMatches = text.matchAll(/CCEffect\s*%\{[\s\S]*?\}%/g);
        for (const match of ccEffectMatches) {
            // 验证YAML语法
            const yamlContent = match[0].slice(match[0].indexOf('%{') + 2, -2);
            try {
                // 这里可以使用yaml解析库验证语法
            } catch (error) {
                const range = this.getMatchRange(document, match);
                diagnostics.push(new vscode.Diagnostic(
                    range,
                    `CCEffect YAML语法错误: ${error.message}`,
                    vscode.DiagnosticSeverity.Error
                ));
            }
        }
        
        // 检查CCProgram块语法
        const ccProgramMatches = text.matchAll(/CCProgram\s+(\w+)\s*%\{[\s\S]*?\}%/g);
        for (const match of ccProgramMatches) {
            this.validateGLSLSyntax(document, match, diagnostics);
        }
    }
    
    private checkBestPractices(document: vscode.TextDocument, text: string, diagnostics: vscode.Diagnostic[]): void {
        // 检查性能最佳实践
        const lines = text.split('\n');
        
        lines.forEach((line, index) => {
            const trimmedLine = line.trim();
            
            // 检查精度声明
            if (trimmedLine.includes('float') && !text.includes('precision')) {
                const range = new vscode.Range(index, 0, index, line.length);
                diagnostics.push(new vscode.Diagnostic(
                    range,
                    '建议在着色器开头声明精度：precision mediump float;',
                    vscode.DiagnosticSeverity.Warning
                ));
            }
            
            // 检查discard使用
            if (trimmedLine.includes('discard')) {
                const range = new vscode.Range(index, line.indexOf('discard'), index, line.indexOf('discard') + 7);
                diagnostics.push(new vscode.Diagnostic(
                    range,
                    '过度使用discard可能影响性能，特别是在移动设备上',
                    vscode.DiagnosticSeverity.Information
                ));
            }
            
            // 检查复杂数学函数
            const expensiveFunctions = ['pow', 'sin', 'cos', 'tan', 'exp', 'log'];
            expensiveFunctions.forEach(func => {
                if (trimmedLine.includes(func + '(')) {
                    const range = new vscode.Range(index, line.indexOf(func), index, line.indexOf(func) + func.length);
                    diagnostics.push(new vscode.Diagnostic(
                        range,
                        `${func}是昂贵的数学函数，考虑使用查找表或近似算法`,
                        vscode.DiagnosticSeverity.Information
                    ));
                }
            });
        });
    }
    
    private validateGLSLSyntax(document: vscode.TextDocument, match: RegExpMatchArray, diagnostics: vscode.Diagnostic[]): void {
        // 简化的GLSL语法验证
        const glslContent = match[0];
        
        // 检查括号匹配
        let braceCount = 0;
        let parenCount = 0;
        
        for (let i = 0; i < glslContent.length; i++) {
            switch (glslContent[i]) {
                case '{': braceCount++; break;
                case '}': braceCount--; break;
                case '(': parenCount++; break;
                case ')': parenCount--; break;
            }
        }
        
        if (braceCount !== 0 || parenCount !== 0) {
            const range = this.getMatchRange(document, match);
            diagnostics.push(new vscode.Diagnostic(
                range,
                '括号不匹配',
                vscode.DiagnosticSeverity.Error
            ));
        }
    }
    
    private getMatchRange(document: vscode.TextDocument, match: RegExpMatchArray): vscode.Range {
        const text = document.getText();
        const startIndex = match.index || 0;
        const endIndex = startIndex + match[0].length;
        
        const startPos = document.positionAt(startIndex);
        const endPos = document.positionAt(endIndex);
        
        return new vscode.Range(startPos, endPos);
    }
    
    public dispose(): void {
        this.diagnosticCollection.dispose();
    }
}

// src/previewProvider.ts
class CocosShaderPreviewProvider implements vscode.WebviewViewProvider {
    private webviewView?: vscode.WebviewView;
    private currentDocument?: vscode.TextDocument;
    
    constructor(private context: vscode.ExtensionContext) {}
    
    public resolveWebviewView(
        webviewView: vscode.WebviewView,
        context: vscode.WebviewViewResolveContext,
        token: vscode.CancellationToken
    ): void {
        this.webviewView = webviewView;
        
        webviewView.webview.options = {
            enableScripts: true,
            localResourceRoots: [this.context.extensionUri]
        };
        
        webviewView.webview.html = this.getWebviewContent();
        
        // 监听文档变化
        vscode.window.onDidChangeActiveTextEditor(this.updatePreview, this);
        vscode.workspace.onDidSaveTextDocument(this.updatePreview, this);
    }
    
    private updatePreview(document?: vscode.TextDocument): void {
        if (!this.webviewView) return;
        
        const activeDocument = document || vscode.window.activeTextEditor?.document;
        if (!activeDocument || activeDocument.languageId !== 'cocos-shader') {
            return;
        }
        
        this.currentDocument = activeDocument;
        const shaderContent = this.parseShaderContent(activeDocument.getText());
        
        this.webviewView.webview.postMessage({
            command: 'updateShader',
            content: shaderContent
        });
    }
    
    private parseShaderContent(text: string): ShaderContent {
        const content: ShaderContent = {
            effect: null,
            programs: []
        };
        
        // 解析CCEffect
        const effectMatch = text.match(/CCEffect\s*%\{([\s\S]*?)\}%/);
        if (effectMatch) {
            try {
                // 这里需要YAML解析
                content.effect = effectMatch[1];
            } catch (error) {
                console.error('解析CCEffect失败:', error);
            }
        }
        
        // 解析CCProgram
        const programMatches = text.matchAll(/CCProgram\s+(\w+)\s*%\{([\s\S]*?)\}%/g);
        for (const match of programMatches) {
            content.programs.push({
                name: match[1],
                source: match[2]
            });
        }
        
        return content;
    }
    
    private getWebviewContent(): string {
        return `
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Cocos Shader Preview</title>
    <style>
        body {
            font-family: var(--vscode-font-family);
            font-size: var(--vscode-font-size);
            color: var(--vscode-foreground);
            background-color: var(--vscode-editor-background);
            margin: 0;
            padding: 10px;
        }
        
        .preview-container {
            width: 100%;
            height: 300px;
            border: 1px solid var(--vscode-panel-border);
            border-radius: 4px;
            overflow: hidden;
            position: relative;
        }
        
        #preview-canvas {
            width: 100%;
            height: 100%;
            display: block;
        }
        
        .info-panel {
            margin-top: 10px;
            padding: 10px;
            background-color: var(--vscode-editor-inactiveSelectionBackground);
            border-radius: 4px;
            font-size: 12px;
        }
        
        .error-message {
            color: var(--vscode-errorForeground);
            background-color: var(--vscode-inputValidation-errorBackground);
            border: 1px solid var(--vscode-inputValidation-errorBorder);
            padding: 8px;
            border-radius: 4px;
            margin-bottom: 10px;
        }
        
        .property-list {
            margin-top: 10px;
        }
        
        .property-item {
            display: flex;
            justify-content: space-between;
            margin-bottom: 5px;
            padding: 2px 0;
        }
        
        .property-name {
            font-weight: bold;
        }
        
        .property-value {
            color: var(--vscode-descriptionForeground);
        }
    </style>
</head>
<body>
    <div class="preview-container">
        <canvas id="preview-canvas"></canvas>
    </div>
    
    <div class="info-panel">
        <h3>着色器信息</h3>
        <div id="shader-info">
            <p>请选择一个Cocos Shader文件来预览</p>
        </div>
    </div>

    <script>
        const vscode = acquireVsCodeApi();
        const canvas = document.getElementById('preview-canvas');
        const gl = canvas.getContext('webgl2') || canvas.getContext('webgl');
        
        let currentShader = null;
        
        // 监听消息
        window.addEventListener('message', event => {
            const message = event.data;
            
            switch (message.command) {
                case 'updateShader':
                    updateShaderPreview(message.content);
                    break;
            }
        });
        
        function updateShaderPreview(content) {
        if (!gl) {
            showError('WebGL不支持');
            return;
        }
            
            try {
                // 编译着色器
                const shader = compileShader(content);
                if (shader) {
                    currentShader = shader;
                    renderPreview();
                    updateInfo(content);
                }
            } catch (error) {
                showError('着色器编译失败: ' + error.message);
            }
        }
        
        function compileShader(content) {
            // 简化的着色器编译
            // 实际实现需要更复杂的GLSL转换逻辑
            const vertexProgram = content.programs.find(p => p.name.includes('vs') || p.name.includes('vert'));
            const fragmentProgram = content.programs.find(p => p.name.includes('fs') || p.name.includes('frag'));
            
            if (!vertexProgram || !fragmentProgram) {
                throw new Error('找不到顶点着色器或片段着色器');
            }
            
            // 转换Cocos Shader到标准GLSL
            const vertexShader = convertToGLSL(vertexProgram.source, 'vertex');
            const fragmentShader = convertToGLSL(fragmentProgram.source, 'fragment');
            
            return createShaderProgram(vertexShader, fragmentShader);
        }
        
        function convertToGLSL(source, type) {
            // 简化的转换逻辑
            let glslSource = source;
            
            // 移除Cocos特定的语法
            glslSource = glslSource.replace(/CCGlobal\s*\{[\s\S]*?\}/g, '');
            glslSource = glslSource.replace(/CCLocal\s*\{[\s\S]*?\}/g, '');
            
            // 添加WebGL兼容的头部
            if (type === 'vertex') {
                glslSource = 'attribute vec3 a_position;\\n' + glslSource;
            } else {
                glslSource = 'precision mediump float;\\n' + glslSource;
            }
            
            return glslSource;
        }
        
        function createShaderProgram(vertexSource, fragmentSource) {
            const vertexShader = compileShaderSource(gl.VERTEX_SHADER, vertexSource);
            const fragmentShader = compileShaderSource(gl.FRAGMENT_SHADER, fragmentSource);
            
            const program = gl.createProgram();
            gl.attachShader(program, vertexShader);
            gl.attachShader(program, fragmentShader);
            gl.linkProgram(program);
            
            if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
                throw new Error('着色器程序链接失败: ' + gl.getProgramInfoLog(program));
            }
            
            return program;
        }
        
        function compileShaderSource(type, source) {
            const shader = gl.createShader(type);
            gl.shaderSource(shader, source);
            gl.compileShader(shader);
            
            if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
                throw new Error('着色器编译失败: ' + gl.getShaderInfoLog(shader));
            }
            
            return shader;
        }
        
        function renderPreview() {
            if (!currentShader) return;
            
            // 简单的预览渲染
            gl.useProgram(currentShader);
            gl.viewport(0, 0, canvas.width, canvas.height);
            gl.clearColor(0.2, 0.2, 0.2, 1.0);
            gl.clear(gl.COLOR_BUFFER_BIT);
            
            // 这里可以渲染一个简单的平面或立方体来展示着色器效果
        }
        
        function updateInfo(content) {
            const infoDiv = document.getElementById('shader-info');
            
            let html = '<div class="property-list">';
            html += \`<div class="property-item"><span class="property-name">程序数量:</span><span class="property-value">\${content.programs.length}</span></div>\`;
            
            content.programs.forEach(program => {
                html += \`<div class="property-item"><span class="property-name">\${program.name}:</span><span class="property-value">已编译</span></div>\`;
            });
            
            html += '</div>';
            infoDiv.innerHTML = html;
        }
        
        function showError(message) {
            const infoDiv = document.getElementById('shader-info');
            infoDiv.innerHTML = \`<div class="error-message">\${message}</div>\`;
        }
        
        // 初始化画布尺寸
        function resizeCanvas() {
            const rect = canvas.getBoundingClientRect();
            canvas.width = rect.width;
            canvas.height = rect.height;
        }
        
        window.addEventListener('resize', resizeCanvas);
        resizeCanvas();
    </script>
</body>
</html>
        `;
    }
}

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