/* eslint-disable max-len */
/* eslint-disable @typescript-eslint/no-explicit-any */
/* eslint-disable @typescript-eslint/no-non-null-assertion */
import { CalculationSpec, LookUpRefSpec, TypeImportSpec } from '../schema/WebApiSchema.js';
import { Edge } from '../types/ImportResult.js';
import { PluginContext } from '../types/PluginContext.js';
import { SqupContext } from '../types/SqupContext.js';
import { PerformCalculation } from './Calculations.js';
import { CallLookUp } from './CallLookup.js';
import { EvaluateCondition } from './EvaluateCondition.js';
import { getArray } from './GetArray.js';
import { referenceData } from './Render.js';
import { handleSimpleField } from './Util.js';

export async function CreateVertex(
    pluginContext: PluginContext,
    importTypeSpec: TypeImportSpec,
    squpContext: SqupContext,
    object: Record<string, any> = {},
    parentItems: Record<string, any>[] = []): Promise<{ vertex?: Record<string, any>, edges: Edge[] }> {
    const result: { vertex?: Record<string, any>, edges: Edge[] } = {
        vertex: importTypeSpec.fields.length > 0 ? { type: importTypeSpec.type, sourceType: importTypeSpec.sourceType } : undefined,
        edges: []
    };

    const baseReplacements: Record<string, any> = {
        object,
        plugin: pluginContext.plugin
    };
    if (parentItems.length > 0) {
        baseReplacements.parent = parentItems[0];
        baseReplacements.parents = parentItems;
    }

    for (const field of importTypeSpec.fields) {
        if (Object.hasOwnProperty.call(field, 'condition') && field.condition) {
            const condition = EvaluateCondition(pluginContext, squpContext, field.condition, baseReplacements);
            if (condition === false) {
                continue;
            }
        }

        if (Array.isArray(field.calc)) {
            for (const preStep of field.calc) {
                if (preStep.condition) {
                    const r = EvaluateCondition(pluginContext, squpContext, preStep.condition, baseReplacements);
                    if (!r) {
                        continue;
                    }
                }
                if ((preStep as any).lookUp) {
                    const lookUpRef = preStep as any as LookUpRefSpec;
                    baseReplacements[lookUpRef.name] = await CallLookUp(pluginContext, squpContext, lookUpRef, baseReplacements);
    
                } else {
                    const calculation = preStep as any as CalculationSpec;
                    baseReplacements[calculation.name] = PerformCalculation(pluginContext, squpContext, calculation.expression, baseReplacements);
                }
            }
        }

        handleSimpleField(pluginContext, field, result.vertex!, baseReplacements);

    }
    if (result.vertex && Array.isArray(importTypeSpec.links) && importTypeSpec.links.length > 0) {
        result.vertex.links = [];
        for (const link of importTypeSpec.links) {
            const url = referenceData(link.url, pluginContext, baseReplacements);
            if (url) {
                result.vertex.links.push({ label: link.label, url });
            }
        }
    }
    if (Array.isArray(importTypeSpec.edges)) {
        for (const edge of importTypeSpec.edges) {
            if (edge.forEach) {
                if (!edge.forEach.startsWith('@')) {
                    throw new Error(`Invalid forEach value (${edge.forEach}) - must start with "@"`);
                }
                const arr = getArray(object, edge.forEach.substring(1));
                if (Array.isArray(arr)) {
                    for (const el of arr) {
                        const replacements = {
                            ...baseReplacements,
                            parent: el,
                            parentItems: [el, ...(parentItems)]
                        };
                        const inV = referenceData(edge.inV, pluginContext, replacements);
                        if (!inV) {
                            throw new Error(`Edge "${edge.label}" inV not found: "${edge.inV}"`);
                        }
                        const outV = referenceData(edge.outV, pluginContext, replacements);
                        if (!outV) {
                            throw new Error(`Edge "${edge.label}" outV not found: "${edge.outV}"`);
                        }
                        result.edges.push({ label: edge.label, inV: inV.toString(), outV: outV.toString() });
                    }
                }
            } else {
                const inV = referenceData(edge.inV, pluginContext, baseReplacements);
                if (!inV) {
                    throw new Error(`Edge "${edge.label}" inV not found: "${edge.inV}"`);
                }
                const outV = referenceData(edge.outV, pluginContext, baseReplacements);
                if (!outV) {
                    throw new Error(`Edge "${edge.label}" outV not found: "${edge.outV}"`);
                }
                result.edges.push({ label: edge.label, inV: inV.toString(), outV: outV.toString() });
            }
        }
    }
    return result;
}