/**
 * Code Generation Module
 * Generates API request code snippets in multiple languages and frameworks
 */
const CodeGenerator = (() => {
    "use strict";

    /**
     * Generate code in specified language
     */
    function generate(language, request, options = {}) {
        const generator = generators[language.toLowerCase()];
        if (!generator) {
            return `// Language "${language}" not supported`;
        }
        return generator(request, options);
    }

    /**
     * Get list of supported languages
     */
    function getSupportedLanguages() {
        return Object.keys(generators).sort();
    }

    // Language generators
    const generators = {
        curl: (req) => generateCurl(req),
        fetch: (req) => generateFetch(req),
        axios: (req) => generateAxios(req),
        httpclient: (req) => generateHttpClient(req),
        httppy: (req) => generatePythonHttp(req),
        requests: (req) => generatePythonRequests(req),
        httpgo: (req) => generateGoHttp(req),
        csharp: (req) => generateCSharp(req),
        javascript: (req) => generateFetch(req),
        typescript: (req) => generateFetch(req),
        ruby: (req) => generateRuby(req),
        php: (req) => generatePhp(req),
        java: (req) => generateJava(req),
        kotlin: (req) => generateKotlin(req),
        powershell: (req) => generatePowerShell(req),
        swift: (req) => generateSwift(req),
    };

    function escapeString(str) {
        return str
            .replace(/\\/g, '\\\\')
            .replace(/"/g, '\\"')
            .replace(/\n/g, '\\n')
            .replace(/\r/g, '\\r')
            .replace(/\t/g, '\\t');
    }

    function escapeStringForJson(str) {
        return JSON.stringify(str);
    }

    // ============= cURL =============
    function generateCurl(req) {
        let cmd = 'curl -X ' + req.method + ' ';

        // Headers
        Object.entries(req.headers || {}).forEach(([key, value]) => {
            cmd += `-H ${escapeStringForJson(key + ': ' + value)} `;
        });

        // Body
        if (req.body) {
            cmd += `-d ${escapeStringForJson(req.body)} `;
        }

        // URL
        cmd += escapeStringForJson(req.url);

        return cmd;
    }

    // ============= Fetch API =============
    function generateFetch(req) {
        let code = `const url = '${escapeString(req.url)}';\n\n`;
        code += `const options = {\n`;
        code += `  method: '${req.method}',\n`;

        if (Object.keys(req.headers || {}).length > 0) {
            code += `  headers: {\n`;
            Object.entries(req.headers).forEach(([key, value]) => {
                code += `    '${escapeString(key)}': '${escapeString(String(value))}',\n`;
            });
            code += `  },\n`;
        }

        if (req.body) {
            code += `  body: ${typeof req.body === 'string' && req.body.startsWith('{') ? 'JSON.stringify(' + req.body + ')' : escapeStringForJson(req.body)},\n`;
        }

        code += `};\n\n`;
        code += `try {\n`;
        code += `  const response = await fetch(url, options);\n`;
        code += `  const data = await response.json();\n`;
        code += `  console.log('Success:', data);\n`;
        code += `} catch (error) {\n`;
        code += `  console.error('Error:', error);\n`;
        code += `}`;

        return code;
    }

    // ============= Axios =============
    function generateAxios(req) {
        let code = `import axios from 'axios';\n\n`;
        code += `const config = {\n`;
        code += `  method: '${req.method.toLowerCase()}',\n`;
        code += `  url: '${escapeString(req.url)}',\n`;

        if (Object.keys(req.headers || {}).length > 0) {
            code += `  headers: {\n`;
            Object.entries(req.headers).forEach(([key, value]) => {
                code += `    '${escapeString(key)}': '${escapeString(String(value))}',\n`;
            });
            code += `  },\n`;
        }

        if (req.body) {
            code += `  data: ${typeof req.body === 'string' && req.body.startsWith('{') ? req.body : escapeStringForJson(req.body)},\n`;
        }

        code += `};\n\n`;
        code += `axios(config)\n`;
        code += `  .then((response) => console.log(response.data))\n`;
        code += `  .catch((error) => console.error(error));`;

        return code;
    }

    // ============= Python - Requests =============
    function generatePythonRequests(req) {
        let code = `import requests\n\n`;
        code += `url = '${escapeString(req.url)}'\n`;

        if (Object.keys(req.headers || {}).length > 0) {
            code += `headers = {\n`;
            Object.entries(req.headers).forEach(([key, value]) => {
                code += `    '${escapeString(key)}': '${escapeString(String(value))}',\n`;
            });
            code += `}\n`;
        } else {
            code += `headers = {}\n`;
        }

        if (req.body) {
            code += `\ndata = ${req.body}\n\n`;
            code += `response = requests.${req.method.toLowerCase()}(url, json=data, headers=headers)\n`;
        } else {
            code += `\nresponse = requests.${req.method.toLowerCase()}(url, headers=headers)\n`;
        }

        code += `print(response.json())`;

        return code;
    }

    // ============= Python - HTTP =============
    function generatePythonHttp(req) {
        let code = `import http.client\nimport json\n\n`;
        const url = new URL(req.url);
        const host = url.hostname;
        const path = url.pathname + url.search;

        code += `conn = http.client.HTTPSConnection("${host}")\n`;

        if (Object.keys(req.headers || {}).length > 0) {
            code += `headers = {\n`;
            Object.entries(req.headers).forEach(([key, value]) => {
                code += `    "${escapeString(key)}": "${escapeString(String(value))}",\n`;
            });
            code += `}\n`;
        } else {
            code += `headers = {}\n`;
        }

        if (req.body) {
            code += `\nbody = ${req.body}\n`;
            code += `conn.request("${req.method}", "${escapeString(path)}", json.dumps(body), headers)\n`;
        } else {
            code += `\nconn.request("${req.method}", "${escapeString(path)}", headers=headers)\n`;
        }

        code += `response = conn.getresponse()\ndata = response.read()\nprint(data.decode())`;

        return code;
    }

    // ============= Go =============
    function generateGoHttp(req) {
        let code = `package main\n\nimport (\n\t"fmt"\n\t"io"\n\t"net/http"\n)\n\n`;
        code += `func main() {\n`;
        code += `\treq, _ := http.NewRequest("${req.method}", "${escapeString(req.url)}", nil)\n`;

        Object.entries(req.headers || {}).forEach(([key, value]) => {
            code += `\treq.Header.Add("${escapeString(key)}", "${escapeString(String(value))}")\n`;
        });

        code += `\n\tres, _ := http.DefaultClient.Do(req)\n`;
        code += `\tdefer res.Body.Close()\n`;
        code += `\tbody, _ := io.ReadAll(res.Body)\n`;
        code += `\tfmt.Println(string(body))\n`;
        code += `}`;

        return code;
    }

    // ============= C# / .NET =============
    function generateCSharp(req) {
        let code = `using System;\nusing System.Net.Http;\nusing System.Threading.Tasks;\n\n`;
        code += `class Program {\n`;
        code += `    static async Task Main() {\n`;
        code += `        using (var client = new HttpClient()) {\n`;

        Object.entries(req.headers || {}).forEach(([key, value]) => {
            if (key.toLowerCase() !== 'content-type') {
                code += `            client.DefaultRequestHeaders.Add("${escapeString(key)}", "${escapeString(String(value))}");\n`;
            }
        });

        if (req.body) {
            code += `\n            var content = new StringContent("${escapeString(req.body)}", null, "application/json");\n`;
            code += `            var response = await client.${req.method.charAt(0) + req.method.slice(1).toLowerCase()}Async("${escapeString(req.url)}", content);\n`;
        } else {
            code += `\n            var response = await client.GetAsync("${escapeString(req.url)}");\n`;
        }

        code += `            var result = await response.Content.ReadAsStringAsync();\n`;
        code += `            Console.WriteLine(result);\n`;
        code += `        }\n`;
        code += `    }\n`;
        code += `}`;

        return code;
    }

    // ============= Ruby =============
    function generateRuby(req) {
        let code = `require 'net/http'\nrequire 'json'\n\n`;
        code += `url = URI('${escapeString(req.url)}')\n`;
        code += `http = Net::HTTP.new(url.host, url.port)\n`;
        code += `http.use_ssl = true\n\n`;

        const methodMap = { 'GET': 'Get', 'POST': 'Post', 'PUT': 'Put', 'PATCH': 'Patch', 'DELETE': 'Delete' };
        const method = methodMap[req.method] || 'Get';

        code += `request = Net::HTTP::${method}.new(url.request_uri)\n`;

        Object.entries(req.headers || {}).forEach(([key, value]) => {
            code += `request['${escapeString(key)}'] = '${escapeString(String(value))}'\n`;
        });

        if (req.body) {
            code += `request.body = ${req.body}\n`;
        }

        code += `\nresponse = http.request(request)\nputs response.body`;

        return code;
    }

    // ============= PHP =============
    function generatePhp(req) {
        let code = `<?php\n\n$url = '${escapeString(req.url)}';\n`;
        code += `$method = '${req.method}';\n\n`;
        code += `$options = array(\n`;
        code += `    'http' => array(\n`;
        code += `        'method' => $method,\n`;

        if (Object.keys(req.headers || {}).length > 0) {
            code += `        'header' => array(\n`;
            Object.entries(req.headers).forEach(([key, value]) => {
                code += `            '${escapeString(key)}: ${String(value)}',\n`;
            });
            code += `        ),\n`;
        }

        if (req.body) {
            code += `        'content' => '${escapeString(req.body)}',\n`;
        }

        code += `    )\n);\n\n`;
        code += `$context = stream_context_create($options);\n`;
        code += `$response = file_get_contents($url, false, $context);\n`;
        code += `echo $response;\n\n?>`;

        return code;
    }

    // ============= Java =============
    function generateJava(req) {
        let code = `import java.net.http.HttpClient;\n`;
        code += `import java.net.http.HttpRequest;\n`;
        code += `import java.net.http.HttpResponse;\n`;
        code += `import java.net.URI;\n\n`;
        code += `public class ApiRequest {\n`;
        code += `    public static void main(String[] args) throws Exception {\n`;
        code += `        HttpClient client = HttpClient.newHttpClient();\n\n`;
        code += `        HttpRequest request = HttpRequest.newBuilder()\n`;
        code += `            .uri(URI.create("${escapeString(req.url)}"))\n`;
        code += `            .method("${req.method}", HttpRequest.BodyPublishers.noBody())\n`;

        Object.entries(req.headers || {}).forEach(([key, value]) => {
            code += `            .header("${escapeString(key)}", "${escapeString(String(value))}")\n`;
        });

        code += `            .build();\n\n`;
        code += `        HttpResponse<String> response = client.send(request,\n`;
        code += `            HttpResponse.BodyHandlers.ofString());\n\n`;
        code += `        System.out.println(response.body());\n`;
        code += `    }\n`;
        code += `}`;

        return code;
    }

    // ============= Kotlin =============
    function generateKotlin(req) {
        let code = `import java.net.HttpURLConnection\nimport java.net.URL\n\n`;
        code += `fun main() {\n`;
        code += `    val url = URL("${escapeString(req.url)}")\n`;
        code += `    val connection = url.openConnection() as HttpURLConnection\n`;
        code += `    connection.requestMethod = "${req.method}"\n\n`;

        Object.entries(req.headers || {}).forEach(([key, value]) => {
            code += `    connection.setRequestProperty("${escapeString(key)}", "${escapeString(String(value))}")\n`;
        });

        code += `\n    val inputStream = connection.inputStream\n`;
        code += `    val response = inputStream.bufferedReader().use { it.readText() }\n`;
        code += `    println(response)\n`;
        code += `}`;

        return code;
    }

    // ============= PowerShell =============
    function generatePowerShell(req) {
        let code = `$uri = "${escapeString(req.url)}"\n`;
        code += `$method = "${req.method}"\n`;

        if (Object.keys(req.headers || {}).length > 0) {
            code += `$headers = @{\n`;
            Object.entries(req.headers).forEach(([key, value]) => {
                code += `    "${escapeString(key)}" = "${escapeString(String(value))}"\n`;
            });
            code += `}\n\n`;
        }

        if (req.body) {
            code += `$body = '${escapeString(req.body)}'\n`;
            code += `$response = Invoke-WebRequest -Uri $uri -Method $method -Headers $headers -Body $body\n`;
        } else {
            code += `$response = Invoke-WebRequest -Uri $uri -Method $method`;
            if (Object.keys(req.headers || {}).length > 0) {
                code += ` -Headers $headers`;
            }
            code += `\n`;
        }

        code += `$response.Content`;

        return code;
    }

    // ============= Swift =============
    function generateSwift(req) {
        let code = `import Foundation\n\nlet url = URL(string: "${escapeString(req.url)}")!\n`;
        code += `var request = URLRequest(url: url)\n`;
        code += `request.httpMethod = "${req.method}"\n\n`;

        Object.entries(req.headers || {}).forEach(([key, value]) => {
            code += `request.setValue("${escapeString(String(value))}", forHTTPHeaderField: "${escapeString(key)}")\n`;
        });

        if (req.body) {
            code += `\nrequest.httpBody = "${escapeString(req.body)}".data(using: .utf8)\n`;
        }

        code += `\nlet task = URLSession.shared.dataTask(with: request) { data, response, error in\n`;
        code += `    if let data = data {\n`;
        code += `        let json = String(data: data, encoding: .utf8)!\n`;
        code += `        print(json)\n`;
        code += `    }\n`;
        code += `}\n`;
        code += `task.resume()`;

        return code;
    }

    // Public API
    return {
        generate,
        getSupportedLanguages,
        escapeString
    };
})();

// Export for use in other modules
if (typeof module !== 'undefined' && module.exports) {
    module.exports = CodeGenerator;
}