'use strict';

/**
 * Node-RED Function 节点脚本：准备大模型 HTTP 请求。
 * 将生成 prompt、HTTP 请求参数，并把上下文写入 msg.llmContext。
 */

const DEFAULT_API_KEY = 'sk-lbGrsUPL1iby86h554FaE536C343435dAa9bA65967A840B2';
const DEFAULT_BASE_URL = 'https://aiproxy.petrotech.cnpc/v1';
const DEFAULT_ENDPOINT_PATH = '/chat/completions';
const DEFAULT_MODEL = 'deepseek-v3';

function prepareLlmRequest(msg, node) {
    if (!msg.operationId) {
        msg.operationId = 'createResource';
    }

    try {
        const apiDoc = extractOpenApiDocument(msg);
        const operationCtx = resolveOperationContext(msg, apiDoc);

        if (!operationCtx.operation) {
            const err = `未找到匹配的接口定义（operationId=${operationCtx.requestedOperationId || '未指定'}, path=${operationCtx.requestedPath || '未指定'}, method=${operationCtx.requestedMethod || '未指定'})`;
            node.error(err, msg);
            msg.error = err;
            return null;
        }

        const prompt = buildPrompt(operationCtx, apiDoc, msg);
        const requestPayload = buildRequestPayload(prompt, msg);

        const apiKey = (msg.llm && msg.llm.apiKey) || DEFAULT_API_KEY;
        const baseUrl = (msg.llm && msg.llm.baseUrl) || DEFAULT_BASE_URL;
        const endpointPath = (msg.llm && msg.llm.endpoint) || DEFAULT_ENDPOINT_PATH;

        const url = buildUrl(baseUrl, endpointPath);
        msg.method = 'POST';
        msg.url = url;
        msg.headers = Object.assign({}, msg.headers, {
            'Content-Type': 'application/json',
            'Authorization': `Bearer ${apiKey}`,
        });
        msg.payload = requestPayload;
        msg.rejectUnauthorized = false;

        msg.llmContext = {
            prompt,
            operationCtx,
            provider: 'dashscope',
            requestConfig: {
                baseUrl,
                endpointPath,
                model: requestPayload.model,
                temperature: requestPayload.temperature,
            },
        };
        delete msg.error;
        return msg;
    } catch (error) {
        node.error(`LLM 请求准备失败：${error.message}`, msg);
        msg.error = error.message;
        return null;
    }
}

function extractOpenApiDocument(message) {
    const candidate =
        message && message.oas_def ? message.oas_def :
            message && message.swagger ? message.swagger :
                message && message.payload ? message.payload :
                    null;

    if (!candidate) {
        throw new Error('未提供 OpenAPI 文档（需要 msg.oas_def / msg.swagger / msg.payload）');
    }

    if (typeof candidate === 'string') {
        try {
            return JSON.parse(candidate);
        } catch (error) {
            throw new Error(`OpenAPI JSON 解析失败：${error.message}`);
        }
    }

    if (typeof candidate !== 'object') {
        throw new Error('OpenAPI 文档必须是对象或 JSON 字符串');
    }

    if (!candidate.paths || typeof candidate.paths !== 'object') {
        throw new Error('OpenAPI 文档缺少 paths 字段');
    }

    return candidate;
}

function resolveOperationContext(message, apiDoc) {
    const requestedOperationId =
        (message && message.operationId) ||
        (message && message.req && message.req.body && message.req.body.operationId) ||
        null;

    const requestedPath =
        (message && message.path) ||
        (message && message.req && message.req.body && message.req.body.path) ||
        null;

    const requestedMethodRaw =
        (message && message.method) ||
        (message && message.req && message.req.body && message.req.body.method) ||
        null;
    const requestedMethod = requestedMethodRaw ? String(requestedMethodRaw).toLowerCase() : null;

    const operations = enumerateOperations(apiDoc);

    let matched = null;
    if (requestedOperationId) {
        matched = operations.find(op => op.operation.operationId === requestedOperationId);
    }

    if (!matched && requestedPath && requestedMethod) {
        matched = operations.find(op => op.path === requestedPath && op.method === requestedMethod);
    }

    let autoSelected = false;
    if (!matched && operations.length > 0) {
        matched = operations[0];
        autoSelected = true;
    }

    return {
        operation: matched ? matched.operation : undefined,
        method: matched ? matched.method : undefined,
        pathItem: matched ? matched.pathItem : undefined,
        path: matched ? matched.path : undefined,
        autoSelected,
        candidates: operations.map(op => ({
            operationId: op.operation && op.operation.operationId ? op.operation.operationId : '',
            method: op.method ? op.method.toUpperCase() : '',
            path: op.path,
            summary: op.operation && op.operation.summary ? op.operation.summary : '',
        })),
        requestedOperationId,
        requestedPath,
        requestedMethod,
    };
}

function enumerateOperations(apiDoc) {
    const results = [];
    const validMethods = ['get', 'put', 'post', 'delete', 'patch', 'options', 'head', 'trace'];
    for (const path of Object.keys(apiDoc.paths || {})) {
        const pathItem = apiDoc.paths[path];
        if (!pathItem || typeof pathItem !== 'object') {
            continue;
        }
        for (const method of validMethods) {
            if (pathItem[method] && typeof pathItem[method] === 'object') {
                results.push({
                    path,
                    method,
                    operation: pathItem[method],
                    pathItem,
                });
            }
        }
    }
    return results;
}

function buildPrompt(operationCtx, apiDoc, message) {
    const operation = operationCtx.operation;
    const method = (operationCtx.method || '').toUpperCase();
    const path = operationCtx.path || '';
    const summary = operation.summary || '';
    const description = operation.description || '';

    const parameters = gatherParameters(operationCtx, apiDoc);
    const requestBodySchema = gatherRequestBodySchema(operation, apiDoc);

    const userNotes = message && message.prompt ? String(message.prompt) : '';
    const requiredFields = extractRequiredFields(requestBodySchema, apiDoc);
    const requiredFieldsText = requiredFields.length > 0
        ? requiredFields.map(field => `- ${field}`).join('\n')
        : '';

    const lines = [];
    lines.push('你是一名负责生成 HTTP 接口测试参数的助手，请严格输出以下结构的 JSON：');
    lines.push('{');
    lines.push('  "pathParams": { ... },');
    lines.push('  "query": { ... },');
    lines.push('  "headers": { ... },');
    lines.push('  "cookies": { ... },');
    lines.push('  "body": { ... },');
    lines.push('  "notes": "..."');
    lines.push('}');
    lines.push('未用到的分区请返回空对象，不要在 JSON 外输出任何文字。');
    lines.push('');
    lines.push('body.data[0] 必须遵守：');
    lines.push('- 覆盖 schema 中声明的全部必填字段，并给出符合字段类型/格式的真实感样例值。');
    lines.push('- 非必填字段也尽可能全覆盖');
    lines.push('- 不得遗漏必填字段；若 schema 内有嵌套对象/数组的必填字段，同样要补齐。');
    lines.push('- 保持数值、日期、字符串等格式，只在 schema 无提示时使用 "sample"、"2025-01-01" 等占位值。');
    if (requiredFieldsText) {
        lines.push('必填字段清单（必须全部出现在 body.data[0] 中）：');
        lines.push(requiredFieldsText);
    }
    lines.push('');
    lines.push('若 schema 中存在数组元素或复合结构的必填字段，也要为这些子字段提供值。');
    lines.push('');
    lines.push(`Target operation: ${method} ${path}`);

    if (summary) {
        lines.push(`Summary: ${summary}`);
    }
    if (description) {
        lines.push(`Description: ${description}`);
    }
    if (parameters.length > 0) {
        lines.push('Parameters:');
        for (const param of parameters) {
            lines.push(`- [${param.in}] ${param.name}: ${param.type || 'any'}${param.required ? ' (required)' : ''}${param.description ? ` - ${param.description}` : ''}`);
        }
    } else {
        lines.push('Parameters: none defined.');
    }

    if (requestBodySchema) {
        lines.push('Request body schema (JSON Schema excerpt):');
        lines.push(indentSnippet(JSON.stringify(requestBodySchema, null, 2), 2));
    } else {
        lines.push('Request body: not defined.');
    }

    if (userNotes) {
        lines.push('');
        lines.push('User notes:');
        lines.push(userNotes);
    }

    return lines.join('\n');
}

function gatherParameters(operationCtx, apiDoc) {
    const aggregated = [];
    const seen = new Set();

    const sources = [];
    if (Array.isArray(operationCtx.pathItem && operationCtx.pathItem.parameters)) {
        sources.push(operationCtx.pathItem.parameters);
    }
    if (Array.isArray(operationCtx.operation.parameters)) {
        sources.push(operationCtx.operation.parameters);
    }

    for (const list of sources) {
        for (const param of list) {
            if (!param || typeof param !== 'object') {
                continue;
            }
            const resolved = resolveMaybeRef(param, apiDoc);
            const key = `${resolved.in}:${resolved.name}`;
            if (!resolved.name || seen.has(key)) {
                continue;
            }
            seen.add(key);
            aggregated.push({
                name: resolved.name,
                in: resolved.in || 'query',
                required: !!resolved.required,
                description: resolved.description || '',
                type: resolved.schema ? inferFriendlyType(resolved.schema, apiDoc) : '',
            });
        }
    }

    return aggregated;
}

function gatherRequestBodySchema(operation, apiDoc) {
    const requestBody = resolveMaybeRef(operation.requestBody, apiDoc);
    if (!requestBody || typeof requestBody !== 'object' || !requestBody.content) {
        return null;
    }

    const content = requestBody.content;
    const mediaType = Object.keys(content).find(key => key.includes('json')) || Object.keys(content)[0];
    if (!mediaType) {
        return null;
    }

    const mediaObject = resolveMaybeRef(content[mediaType], apiDoc);
    if (!mediaObject || typeof mediaObject !== 'object' || !mediaObject.schema) {
        return null;
    }

    const schema = resolveMaybeRef(mediaObject.schema, apiDoc);
    return resolveSchemaDeep(schema, apiDoc);
}

function inferFriendlyType(schema, apiDoc) {
    if (!schema) {
        return '';
    }
    const resolved = resolveMaybeRef(schema, apiDoc);
    if (!resolved || typeof resolved !== 'object') {
        return '';
    }

    if (resolved.type) {
        if (resolved.type === 'array' && resolved.items) {
            const itemType = inferFriendlyType(resolved.items, apiDoc) || 'any';
            return `[${itemType}]`;
        }
        return resolved.type;
    }

    if (resolved.enum && Array.isArray(resolved.enum)) {
        return `enum(${resolved.enum.slice(0, 3).join(', ')}${resolved.enum.length > 3 ? ', …' : ''})`;
    }

    if (resolved.properties) {
        return 'object';
    }

    return '';
}

function buildRequestPayload(prompt, message) {
    const systemPrompt = (message.llm && message.llm.systemPrompt) ||
        'You write JSON only. Focus on realistic values for testing HTTP APIs.';

    const model = (message.llm && message.llm.model) || DEFAULT_MODEL;
    const temperature = (message.llm && typeof message.llm.temperature === 'number')
        ? message.llm.temperature : 0.2;

    return {
        model,
        temperature,
        response_format: { type: 'json_object' },
        messages: [
            { role: 'system', content: systemPrompt },
            { role: 'user', content: prompt },
        ],
    };
}

function buildUrl(baseUrl, endpointPath) {
    const normalizedBase = baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
    const path = endpointPath.startsWith('/') ? endpointPath.slice(1) : endpointPath;
    return `${normalizedBase}${path}`;
}

function resolveMaybeRef(node, apiDoc) {
    if (!node || typeof node !== 'object') {
        return node;
    }
    if (!node.$ref) {
        return node;
    }

    const resolved = resolveRef(node.$ref, apiDoc);
    if (!resolved || typeof resolved !== 'object') {
        return node;
    }

    const remainder = Object.assign({}, node);
    delete remainder.$ref;
    return Object.assign({}, clone(resolved), remainder);
}

function resolveRef(ref, apiDoc) {
    if (typeof ref !== 'string' || !ref.startsWith('#/')) {
        return null;
    }

    const tokens = ref.slice(2).split('/').map(unescapeRefToken);
    let current = apiDoc;
    for (const token of tokens) {
        if (current && typeof current === 'object' && Object.prototype.hasOwnProperty.call(current, token)) {
            current = current[token];
        } else {
            return null;
        }
    }
    return current;
}

function unescapeRefToken(token) {
    return token.replace(/~1/g, '/').replace(/~0/g, '~');
}

function indentSnippet(text, indentLevel, maxLength) {
    const trimmed = maxLength && text.length > maxLength ? `${text.slice(0, maxLength)}…` : text;
    const indent = ' '.repeat(indentLevel * 2);
    return trimmed.split('\n').map(line => `${indent}${line}`).join('\n');
}

function clone(value) {
    return value == null ? value : JSON.parse(JSON.stringify(value));
}

function extractRequiredFields(schema, apiDoc) {
    const result = new Set();
    collectRequiredFields(schema, apiDoc, result, '');
    return Array.from(result);
}

function collectRequiredFields(schema, apiDoc, result, pathPrefix) {
    if (!schema || typeof schema !== 'object') {
        return;
    }

    if (schema.$ref) {
        const resolved = resolveRef(schema.$ref, apiDoc);
        if (!resolved) {
            return;
        }
        collectRequiredFields(resolveSchemaDeep(resolved, apiDoc), apiDoc, result, pathPrefix);
        return;
    }

    if (Array.isArray(schema.required) && schema.properties && typeof schema.properties === 'object') {
        for (const key of schema.required) {
            const nextPath = pathPrefix ? `${pathPrefix}.${key}` : key;
            result.add(nextPath);
            collectRequiredFields(schema.properties[key], apiDoc, result, nextPath);
        }
    }

    if (schema.type === 'array' && schema.items) {
        const nextPrefix = pathPrefix ? `${pathPrefix}[]` : '[]';
        collectRequiredFields(schema.items, apiDoc, result, nextPrefix);
    }

    if (schema.allOf && Array.isArray(schema.allOf)) {
        for (const part of schema.allOf) {
            collectRequiredFields(part, apiDoc, result, pathPrefix);
        }
    }
}

function resolveSchemaDeep(schema, apiDoc, seen = new Set()) {
    if (!schema || typeof schema !== 'object') {
        return schema;
    }

    if (schema.$ref) {
        const ref = schema.$ref;
        if (seen.has(ref)) {
            return {};
        }
        seen.add(ref);
        const resolved = resolveRef(ref, apiDoc);
        if (!resolved) {
            return schema;
        }
        const merged = Object.assign({}, clone(resolved), clone(schema));
        delete merged.$ref;
        return resolveSchemaDeep(merged, apiDoc, seen);
    }

    const cloned = clone(schema);

    if (cloned.properties && typeof cloned.properties === 'object') {
        for (const key of Object.keys(cloned.properties)) {
            cloned.properties[key] = resolveSchemaDeep(cloned.properties[key], apiDoc, new Set(seen));
        }
    }

    if (cloned.items) {
        cloned.items = resolveSchemaDeep(cloned.items, apiDoc, new Set(seen));
    }

    if (cloned.allOf && Array.isArray(cloned.allOf)) {
        cloned.allOf = cloned.allOf.map(item => resolveSchemaDeep(item, apiDoc, new Set(seen)));
    }

    if (cloned.oneOf && Array.isArray(cloned.oneOf)) {
        cloned.oneOf = cloned.oneOf.map(item => resolveSchemaDeep(item, apiDoc, new Set(seen)));
    }

    if (cloned.anyOf && Array.isArray(cloned.anyOf)) {
        cloned.anyOf = cloned.anyOf.map(item => resolveSchemaDeep(item, apiDoc, new Set(seen)));
    }

    return cloned;
}

return prepareLlmRequest(msg, node);