require('dotenv').config({ path: require('path').resolve(__dirname, '../.env') });
const axios = require('axios');
const OpenAI = require('openai');

const WORKFLOW_VALIDATE_FIELDS = process.env.WORKFLOW_VALIDATE_FIELDS;
const OPENROUTER_BASE_URL = 'https://openrouter.ai/api/v1';
const BRAND_LLM_MODEL = 'openai/gpt-4o';
const TEMPLATE_LLM_MODEL = 'openai/gpt-4o';
const CURL_LLM_MODEL = 'openai/gpt-4o-mini';
const EDIT_CHECK_LLM_MODEL = 'openai/gpt-4o-mini';

if (!WORKFLOW_VALIDATE_FIELDS) throw new Error('Missing WORKFLOW_VALIDATE_FIELDS environment variable');

const DLT_VARIABLE_SPECS = [
    {
        token: '{#numeric#}',
        label: '#numeric',
        purpose: 'Digits-only dynamic values such as OTPs, amounts, or numeric IDs.',
        validation: 'Only digits are allowed.',
    },
    {
        token: '{#url#}',
        label: '#url',
        purpose: 'Web links.',
        validation: 'Must resolve to a valid registered HTTP(S) URL.',
    },
    {
        token: '{#urlott#}',
        label: '#urlott',
        purpose: 'OTT or app-download links.',
        validation: 'Must resolve to a valid registered OTT or APK URL.',
    },
    {
        token: '{#cbn#}',
        label: '#cbn',
        purpose: 'Callback phone numbers.',
        validation: 'Must resolve to a valid registered callback number.',
    },
    {
        token: '{#email#}',
        label: '#email',
        purpose: 'Email addresses.',
        validation: 'Must resolve to a syntactically valid email address.',
    },
    {
        token: '{#alphanumeric#}',
        label: '#alphanumeric',
        purpose: 'Mixed letter-and-number values such as order IDs or booking references.',
        validation: 'Letters and numbers only; avoid spaces and special characters.',
    },
];
const LEGACY_DLT_VAR_TOKEN = '{#var#}';
const SUPPORTED_DLT_TOKENS = [LEGACY_DLT_VAR_TOKEN, ...DLT_VARIABLE_SPECS.map((spec) => spec.token)];
const SUPPORTED_DLT_TOKEN_SET = new Set(SUPPORTED_DLT_TOKENS);
const DLT_PLACEHOLDER_REGEX = /\{#(?:var|numeric|url|urlott|cbn|email|alphanumeric)#\}/g;
const DLT_PLACEHOLDER_LIKE_REGEX = /\{#[^{}]*#\}/g;

const TRAI_RULES_TEXT = [
    '1) Keep the SMS within 160 characters.',
    `2) Use only approved placeholders: ${SUPPORTED_DLT_TOKENS.join(', ')}.`,
    `3) Prefer typed placeholders (${DLT_VARIABLE_SPECS.map((spec) => spec.token).join(', ')}) whenever the value clearly matches that type.`,
    `4) Use ${LEGACY_DLT_VAR_TOKEN} only as a generic fallback for free-form values such as names, product titles, or addresses that do not fit a stricter typed token.`,
    '5) Keep the message strictly transactional: no promotional language.',
    '6) Do not include raw URLs unless the event genuinely requires a link and the placeholder type is appropriate.',
    '7) Do not append a brand or sender signature in the message body unless the exact registered sender ID is explicitly known and required.',
    '8) Sender identifiers must remain DLT-compliant.',
    '9) Allowed punctuation only; avoid malformed symbols or placeholder fragments.',
    '10) The message must match the event and start with clear order or event context.',
].join(' ');

const BRAND_CONTEXT_TONE_OPTIONS = ['friendly', 'professional', 'formal', 'casual', 'energetic'];
const EVENT_DESCRIPTIONS = {
    placed: 'The customer has successfully placed an order',
    confirmed: 'The order has been confirmed by the seller/warehouse',
    dp_assigned: 'A delivery partner has been assigned to deliver the order',
    pack: 'The order has been packed and is ready for dispatch',
    cancelled: 'The order has been cancelled',
    delivery_done: 'The order has been successfully delivered to the customer',
};

let cachedClient = null;

function normalizeText(value) {
    return typeof value === 'string' ? value.trim() : '';
}

function describeDltVariableTypes() {
    return DLT_VARIABLE_SPECS
        .map((spec) => `- ${spec.token}: ${spec.purpose} ${spec.validation}`)
        .join('\n');
}

function getUnsupportedDltTokens(text) {
    return (String(text).match(DLT_PLACEHOLDER_LIKE_REGEX) || [])
        .filter((token) => !SUPPORTED_DLT_TOKEN_SET.has(token));
}

function hasMalformedDltFragments(text) {
    const stripped = String(text).replace(DLT_PLACEHOLDER_LIKE_REGEX, '');
    return stripped.includes('{#') || stripped.includes('#}');
}

function validateTemplateStructure(text) {
    const normalized = normalizeText(text);
    if (!normalized) return 'Template is empty.';
    if (normalized.length > 160) return 'Template exceeds 160 characters.';

    const unsupportedTokens = getUnsupportedDltTokens(normalized);
    if (unsupportedTokens.length > 0) {
        return `Template uses unsupported placeholders: ${unsupportedTokens.join(', ')}.`;
    }

    if (hasMalformedDltFragments(normalized)) {
        return 'Template contains malformed placeholder text.';
    }

    return '';
}

function escapeRegex(value) {
    return String(value || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}

function buildPhraseRegex(phrase) {
    const normalized = normalizeText(phrase).replace(/\s+/g, ' ');
    if (!normalized) return null;

    const parts = normalized.split(' ').filter(Boolean).map(escapeRegex);
    if (parts.length === 0) return null;

    return new RegExp(`(^|[^a-z0-9])${parts.join('\\s+')}([^a-z0-9]|$)`, 'i');
}

function getBlockedBrandPhrases(options = {}) {
    const phrases = [
        options?.brandName,
        ...(Array.isArray(options?.brandTaglines) ? options.brandTaglines : []),
    ]
        .map((value) => normalizeText(value))
        .filter(Boolean);

    return [...new Set(phrases)];
}

function findBlockedBrandPhrase(text, options = {}) {
    const normalizedText = normalizeText(text);
    if (!normalizedText) return '';

    return getBlockedBrandPhrases(options).find((phrase) => {
        const matcher = buildPhraseRegex(phrase);
        return matcher ? matcher.test(normalizedText) : false;
    }) || '';
}

function requestId(prefix) {
    return `${prefix}_${Date.now()}`;
}

function parseJsonField(value, fallback) {
    if (typeof value !== 'string') return value ?? fallback;
    try {
        return JSON.parse(value);
    } catch {
        return fallback;
    }
}

function extractMessageText(content) {
    if (typeof content === 'string') return content.trim();

    if (Array.isArray(content)) {
        return content
            .map((entry) => {
                if (typeof entry === 'string') return entry;
                if (entry && typeof entry.text === 'string') return entry.text;
                return '';
            })
            .join('')
            .trim();
    }

    return '';
}

function tryParseJson(text) {
    const trimmed = normalizeText(text);
    if (!trimmed) return null;

    try {
        return JSON.parse(trimmed);
    } catch {
        // fall through
    }

    const fencedMatch = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
    if (fencedMatch?.[1]) {
        try {
            return JSON.parse(fencedMatch[1].trim());
        } catch {
            // fall through
        }
    }

    const firstBrace = trimmed.indexOf('{');
    const lastBrace = trimmed.lastIndexOf('}');
    if (firstBrace >= 0 && lastBrace > firstBrace) {
        try {
            return JSON.parse(trimmed.slice(firstBrace, lastBrace + 1));
        } catch {
            // fall through
        }
    }

    return null;
}

function isAbsoluteHttpUrl(value) {
    if (!normalizeText(value)) return false;
    try {
        const parsed = new URL(value);
        return parsed.protocol === 'http:' || parsed.protocol === 'https:';
    } catch {
        return false;
    }
}

function getLlmClient() {
    if (cachedClient) return cachedClient;

    const apiKey = normalizeText(process.env.OPENROUTER_API_KEY);
    if (!apiKey) {
        throw new Error('OPENROUTER_API_KEY is not configured');
    }

    const referer = normalizeText(process.env.EXTENSION_BASE_URL);
    const appName = 'SMS Extension';
    const defaultHeaders = {};

    if (referer) defaultHeaders['HTTP-Referer'] = referer;
    if (appName) defaultHeaders['X-Title'] = appName;

    cachedClient = new OpenAI({
        apiKey,
        baseURL: OPENROUTER_BASE_URL,
        defaultHeaders,
    });

    return cachedClient;
}

async function requestStructuredJson({ model, taskName, systemPrompt, userPrompt, temperature = 0.2 }) {
    try {
        const client = getLlmClient();
        const completion = await client.chat.completions.create({
            model,
            temperature,
            response_format: { type: 'json_object' },
            messages: [
                { role: 'system', content: systemPrompt },
                { role: 'user', content: userPrompt },
            ],
        });

        const text = extractMessageText(completion?.choices?.[0]?.message?.content);
        const parsed = tryParseJson(text);

        if (!parsed || typeof parsed !== 'object') {
            throw new Error(`${taskName} returned unreadable JSON`);
        }

        return parsed;
    } catch (error) {
        const details = error.response?.data ? ` | response: ${JSON.stringify(error.response.data)}` : '';
        throw new Error(`${taskName} failed: ${error.message}${details}`);
    }
}

async function postWorkflow(url, payload) {
    try {
        const response = await axios.post(url, payload, {
            headers: { 'Content-Type': 'application/json' },
            maxBodyLength: Infinity,
            timeout: 60000,
        });
        return response.data;
    } catch (error) {
        const details = error.response?.data ? ` | response: ${JSON.stringify(error.response.data)}` : '';
        throw new Error(`Workflow API error (${url}): ${error.message}${details}`);
    }
}

function sanitizeStringArray(value, options = {}) {
    const { maxItems = Infinity, allowUrlsOnly = false } = options;
    if (!Array.isArray(value)) return [];

    const seen = new Set();
    const items = [];

    value.forEach((entry) => {
        if (items.length >= maxItems) return;
        const normalized = normalizeText(String(entry || ''));
        if (!normalized) return;
        if (allowUrlsOnly && !isAbsoluteHttpUrl(normalized)) return;
        if (seen.has(normalized)) return;
        seen.add(normalized);
        items.push(normalized);
    });

    return items;
}

function sanitizeVariableMap(value) {
    if (!value || typeof value !== 'object' || Array.isArray(value)) return {};

    return Object.entries(value).reduce((accumulator, [key, rawValue]) => {
        const normalizedKey = normalizeText(String(key || ''));
        const normalizedValue = normalizeText(String(rawValue || ''));
        if (!normalizedKey || !normalizedValue) return accumulator;
        accumulator[normalizedKey] = normalizedValue;
        return accumulator;
    }, {});
}

async function parseBrandContext(scrapedData = {}) {
    const representativePages = Array.isArray(scrapedData.representativePages)
        ? scrapedData.representativePages.slice(0, 20)
        : [];
    const representativeTextBlocks = Array.isArray(scrapedData.representativeTextBlocks)
        ? scrapedData.representativeTextBlocks.slice(0, 20)
        : [];
    const productPages = Array.isArray(scrapedData.productPages)
        ? scrapedData.productPages.slice(0, 5)
        : [];
    const contentDigest = representativeTextBlocks
        .map((block) => {
            const title = String(block?.title || '').trim();
            const pageType = String(block?.pageType || '').trim();
            const text = String(block?.text || '').trim();
            return [title, pageType, text].filter(Boolean).join(' | ');
        })
        .filter(Boolean)
        .join('\n\n')
        .slice(0, 14000);

    const result = await requestStructuredJson({
        model: BRAND_LLM_MODEL,
        taskName: 'Brand context extraction',
        temperature: 0.2,
        systemPrompt: 'You are a brand analyst for ecommerce storefronts. Infer brand identity from crawl evidence and return only valid JSON that matches the requested schema exactly.',
        userPrompt: [
            'Analyze the storefront evidence below and infer brand context.',
            '',
            'Return only valid JSON with exactly these keys:',
            '{',
            '  "brandName": "string",',
            `  "tone": "one of ${BRAND_CONTEXT_TONE_OPTIONS.join(', ')}",`,
            '  "taglines": ["up to 3 strings"],',
            '  "colors": ["hex colors only"],',
            '  "relevantImageUrls": ["3-5 absolute http(s) image URLs only"],',
            '  "aboutSummary": "2-4 concise customer-facing sentences"',
            '}',
            '',
            'Constraints:',
            '- No markdown.',
            '- No explanatory prose.',
            '- Do not copy the About page verbatim.',
            '- Exclude icons, tracking pixels, and data URLs from images.',
            '',
            `start_url: ${String(scrapedData.startUrl || '')}`,
            `domain: ${String(scrapedData.domain || '')}`,
            `site_stats_json: ${JSON.stringify(scrapedData.siteStats || {})}`,
            `homepage_json: ${JSON.stringify(scrapedData.homepage || {})}`,
            `about_page_json: ${JSON.stringify(scrapedData.aboutPage || {})}`,
            `product_pages_json: ${JSON.stringify(productPages)}`,
            `contact_page_json: ${JSON.stringify(scrapedData.contactPage || {})}`,
            `representative_pages_json: ${JSON.stringify(representativePages)}`,
            `representative_text_blocks_json: ${JSON.stringify(representativeTextBlocks)}`,
            `navigation_json: ${JSON.stringify(scrapedData.navigation || [])}`,
            `policy_pages_json: ${JSON.stringify(scrapedData.policyPages || [])}`,
            `links_json: ${JSON.stringify(scrapedData.links || [])}`,
            `top_images_json: ${JSON.stringify(scrapedData.topImages || [])}`,
            `screenshots_json: ${JSON.stringify(scrapedData.screenshots || [])}`,
            `branding_json: ${JSON.stringify(scrapedData.branding || {})}`,
            `crawl_summary_json: ${JSON.stringify(scrapedData || {})}`,
            `content_digest: ${contentDigest}`,
        ].join('\n'),
    });

    const normalizedTone = normalizeText(String(result.tone || '')).toLowerCase();

    return {
        brandName: normalizeText(String(result.brandName || '')) || 'Unknown Brand',
        tone: BRAND_CONTEXT_TONE_OPTIONS.includes(normalizedTone) ? normalizedTone : 'professional',
        taglines: sanitizeStringArray(result.taglines, { maxItems: 3 }),
        colors: sanitizeStringArray(result.colors),
        relevantImageUrls: sanitizeStringArray(result.relevantImageUrls, { maxItems: 5, allowUrlsOnly: true }),
        aboutSummary: normalizeText(String(result.aboutSummary || '')),
    };
}

async function generateTemplates(brandContext = {}, eventSlug, eventLabel, options = {}) {
    const eventDesc = EVENT_DESCRIPTIONS[eventSlug] || `A "${eventLabel}" event in the order lifecycle`;
    const registeredSenderId = normalizeText(options?.senderId).toUpperCase();
    const blockedBrandPhrases = getBlockedBrandPhrases({
        brandName: brandContext?.brandName,
        brandTaglines: brandContext?.taglines,
    });
    const approvedTemplates = [];
    const seenTemplates = new Set();
    const rejectionReasons = [];

    for (let attempt = 0; attempt < 2 && approvedTemplates.length < 3; attempt += 1) {
        const templateCount = attempt === 0 ? 6 : 8;
        const result = await requestStructuredJson({
            model: TEMPLATE_LLM_MODEL,
            taskName: 'SMS template generation',
            temperature: 0.45,
            systemPrompt: 'You are an expert in Indian transactional SMS templates. Follow the provided constraints exactly, self-check against them, and return only valid JSON.',
            userPrompt: [
                `Generate exactly ${templateCount} distinct transactional SMS templates.`,
                '',
                `Brand: ${String(brandContext.brandName || '')}`,
                `Tone: ${String(brandContext.tone || '')}`,
                `Taglines: ${JSON.stringify(Array.isArray(brandContext.taglines) ? brandContext.taglines : [])}`,
                `Event slug: ${String(eventSlug || '')}`,
                `Event label: ${String(eventLabel || '')}`,
                `Event description: ${eventDesc}`,
                `Registered sender ID: ${registeredSenderId || 'Not provided. Do not append any brand or sender signature.'}`,
                '',
                `Rules: ${TRAI_RULES_TEXT}`,
                '',
                'Approved placeholder types:',
                describeDltVariableTypes(),
                `- ${LEGACY_DLT_VAR_TOKEN}: Generic fallback for free-form values such as customer names, product names, or addresses when a stricter typed token does not fit.`,
                '',
                'Each template must:',
                '- be under 160 characters',
                '- start with clear event or order context',
                '- match the event accurately',
                '- avoid promotional language',
                '- avoid raw URLs unless clearly required for the event',
                '- never mention the brand name or tagline in the message body unless the exact registered sender ID is explicitly required and provided',
                blockedBrandPhrases.length > 0
                    ? `- specifically do not include these phrases: ${blockedBrandPhrases.join(', ')}`
                    : '',
                '',
                rejectionReasons.length > 0
                    ? `Avoid these issues seen in rejected drafts: ${rejectionReasons.slice(-6).join(' | ')}`
                    : '',
                '',
                'Return only valid JSON with exactly this shape:',
                `{ "templates": ["template 1", "template 2", "... up to ${templateCount} templates"] }`,
            ].filter(Boolean).join('\n'),
        });

        const candidateTemplates = sanitizeStringArray(result.templates, { maxItems: templateCount });

        for (const candidate of candidateTemplates) {
            if (approvedTemplates.length >= 3) break;
            if (seenTemplates.has(candidate)) continue;
            seenTemplates.add(candidate);

            const structureIssue = validateTemplateStructure(candidate);
            if (structureIssue) {
                rejectionReasons.push(structureIssue);
                continue;
            }

            const blockedPhrase = findBlockedBrandPhrase(candidate, {
                brandName: brandContext?.brandName,
                brandTaglines: brandContext?.taglines,
            });
            if (blockedPhrase) {
                rejectionReasons.push(`Do not mention "${blockedPhrase}" in the SMS body.`);
                continue;
            }

            const validation = await validateEditedTemplate(candidate, {
                senderId: registeredSenderId,
                eventSlug,
                eventLabel,
                brandName: brandContext?.brandName,
                brandTaglines: brandContext?.taglines,
            });

            if (validation.approved) {
                approvedTemplates.push(candidate);
                continue;
            }

            if (validation.why) {
                rejectionReasons.push(validation.why);
            }
        }
    }

    if (approvedTemplates.length < 3) {
        throw new Error('Could not generate 3 compliant templates. Please try again.');
    }

    return approvedTemplates.slice(0, 3);
}

async function processCurl(rawCurl, approvedTemplate, eventSlug) {
    const result = await requestStructuredJson({
        model: CURL_LLM_MODEL,
        taskName: 'Provider cURL processing',
        temperature: 0.1,
        systemPrompt: 'You are an SMS provider integration expert. Analyze raw provider curls, infer semantic placeholders, and return only valid JSON.',
        userPrompt: [
            'Analyze the provider cURL and return a structured placeholder mapping.',
            '',
            `Approved SMS template:\n${String(approvedTemplate || '')}`,
            '',
            `Event slug: ${String(eventSlug || '')}`,
            '',
            `Raw cURL:\n${String(rawCurl || '')}`,
            '',
            'Instructions:',
            '- identify all placeholder formats in the cURL',
            '- infer semantic field names in camelCase',
            '- normalize placeholders inside processedCurl using those camelCase field names',
            '- build variableMap using the exact DLT token text from the approved template in appearance order',
            `- supported DLT token types include ${SUPPORTED_DLT_TOKENS.join(', ')}`,
            '',
            'Return only valid JSON with exactly this shape:',
            '{',
            '  "processedCurl": "string",',
            '  "variableMap": { "{#numeric#}[0]": "fieldName", "{#var#}[1]": "fieldName" }',
            '}',
        ].join('\n'),
    });

    return {
        processedCurl: String(result.processedCurl || ''),
        variableMap: sanitizeVariableMap(result.variableMap),
    };
}

async function validateEditedTemplate(editedTemplate, options = {}) {
    const structureIssue = validateTemplateStructure(editedTemplate);
    if (structureIssue) {
        return {
            approved: false,
            why: structureIssue,
            workflowResult: { approved: false, why: structureIssue, source: 'deterministic' },
        };
    }

    const registeredSenderId = normalizeText(options?.senderId).toUpperCase();
    const eventSlug = normalizeText(options?.eventSlug);
    const eventLabel = normalizeText(options?.eventLabel);
    const brandName = normalizeText(options?.brandName);
    const blockedBrandPhrase = findBlockedBrandPhrase(editedTemplate, options);
    if (blockedBrandPhrase) {
        return {
            approved: false,
            why: `Remove the brand reference "${blockedBrandPhrase}" from the message body.`,
            workflowResult: { approved: false, why: `Blocked brand phrase: ${blockedBrandPhrase}`, source: 'deterministic' },
        };
    }
    const result = await requestStructuredJson({
        model: EDIT_CHECK_LLM_MODEL,
        taskName: 'Edited template validation',
        temperature: 0,
        systemPrompt: 'You validate Indian transactional SMS templates for compliance and clarity. Return only valid JSON.',
        userPrompt: [
            'Review this edited SMS template and decide whether it should be approved.',
            '',
            `Template:\n${String(editedTemplate || '')}`,
            '',
            eventSlug ? `Event slug: ${eventSlug}` : '',
            eventLabel ? `Event label: ${eventLabel}` : '',
            brandName ? `Brand name: ${brandName}` : '',
            `Registered sender ID: ${registeredSenderId || 'Not provided. Reject appended brand or sender signatures.'}`,
            '',
            `Rules: ${TRAI_RULES_TEXT}`,
            '',
            'Approved placeholder types:',
            describeDltVariableTypes(),
            `- ${LEGACY_DLT_VAR_TOKEN}: Generic fallback for free-form values such as names, product names, or addresses when a stricter typed token does not fit.`,
            '',
            'Approval guidance:',
            '- approve only if the template is clear, transactional, and appears compliant with the rules',
            '- approve typed placeholders like {#numeric#}, {#url#}, {#urlott#}, {#cbn#}, {#email#}, and {#alphanumeric#} when they match the intended dynamic value type',
            `- allow ${LEGACY_DLT_VAR_TOKEN} only as a generic fallback for free-form content that does not fit a stricter typed token`,
            '- reject if a more precise typed token should clearly replace a generic one for numeric, URL, callback, email, or alphanumeric values',
            '- reject if the message mentions the brand name, tagline, or a brand-style signoff in the body',
            '- reject if the message appends a sender signature that does not exactly match the registered sender ID',
            '- reject if it is too promotional, malformed, ambiguous, or clearly non-compliant',
            '- keep the explanation concise and actionable',
            '',
            'Return only valid JSON with exactly this shape:',
            '{ "approved": true, "why": "short explanation" }',
        ].join('\n'),
    });

    const approved = typeof result.approved === 'boolean'
        ? result.approved
        : ['approved', 'pass', 'passed', 'valid', 'ok', 'true'].includes(normalizeText(String(result.approved || result.status || '')).toLowerCase());

    return {
        approved,
        why: normalizeText(String(result.why || result.reason || result.message || '')),
        workflowResult: result,
    };
}

async function validateCurlFields(rawCurl) {
    const payload = {
        curl_b64: Buffer.from(String(rawCurl || ''), 'utf8').toString('base64'),
    };

    const data = await postWorkflow(WORKFLOW_VALIDATE_FIELDS, payload);
    const output = typeof data === 'string' ? parseJsonField(data, {}) : (data || {});
    const isValidCurl = output.is_valid_curl === true || String(output.is_valid_curl).toLowerCase() === 'true';

    return {
        isValidCurl,
        provider: {
            providerName: String(output.provider_name || '').trim(),
            senderId: String(output.dlt_sender_id || '').trim().toUpperCase(),
            dltEntityId: String(output.dlt_entity_id || '').trim(),
            authKey: String(output.api_auth_key || '').trim(),
        },
        reason: String(output.reason || '').trim(),
    };
}

module.exports = {
    parseBrandContext,
    generateTemplates,
    processCurl,
    validateEditedTemplate,
    validateCurlFields,
};