import { FunctionData, ObjectData, ObjectDataType, PrimitiveData, Tag, Variable } from "@cyklang/core";
import loglevel from 'loglevel'
import { structure } from "./cykLang";
import { AlertException } from "./cykRun";
import { Ref } from "vue";
const logger = loglevel.getLogger('cykTableOptions.ts')
logger.setLevel('debug')

/**
 * function parseOptions
 * @param optionsObject 
 * @returns 
 */
export function parseOptions(optionsObject: ObjectData, optSelected: Ref<ObjectData | undefined>, queryFunct: Ref<FunctionData | undefined>): {
    dbResult: ObjectData;
    optEntity: string;
    optCommands: ObjectData;
    optColumns: ObjectData | ObjectDataType | undefined;
    optTableCommands: ObjectData | undefined;
    optCmds: Variable | undefined;
    onloadFunct: FunctionData | undefined;
    optTableRowModel: FunctionData | undefined,
    optCardModel: FunctionData | undefined,
    optRenumberRows: FunctionData | undefined,
    optStyle: string
} {
    if (optionsObject.type.name === 'Tableoptions') {
        throw 'Tableoptions not implemented' 
    }
    else {
        return parseOptions1(optionsObject, optSelected, queryFunct)
    }
}

/**
 * function parseOptions1
 * @param optionsObject 
 * @returns 
 */
function parseOptions1(optionsObject: ObjectData, optSelected: Ref<ObjectData | undefined>, queryFunct: Ref<FunctionData | undefined>): {
    dbResult: ObjectData;
    optEntity: string;
    optCommands: ObjectData;
    optColumns: ObjectData | ObjectDataType | undefined;
    optTableCommands: ObjectData | undefined;
    optCmds: Variable | undefined;
    onloadFunct: FunctionData | undefined;
    optTableRowModel: FunctionData | undefined;
    optCardModel: FunctionData | undefined;
    optRenumberRows: FunctionData | undefined;
    optStyle: string
} {
    const optionsVariables = optionsObject.variables
    let dbResult: ObjectData | undefined;
    let optEntity: string | undefined;
    let optCommands: ObjectData | undefined;
    let optColumns: ObjectData | ObjectDataType | undefined;
    let optTableCommands: ObjectData | undefined;

    let optCmds: Variable | undefined;
    let onloadFunct: FunctionData | undefined;
    let optTableRowModel: FunctionData | undefined;
    let optCardModel: FunctionData | undefined;
    let optRenumberRows: FunctionData | undefined;

    let optStyle: string = optionsObject.tag.attributes.STYLE

    for (let ind = 0; ind < optionsVariables.length(); ind++) {
        const namedVariable = optionsVariables.at(ind)
        if (!namedVariable) continue;
        if (namedVariable.variable.data === null || namedVariable.variable.data === undefined)
            throw 'table_model option [ ' + namedVariable.name + ' ] data undefined';
        switch (namedVariable.name) {
            case 'query':
                if (namedVariable.variable.data.type.name !== 'function') {
                    AlertException(
                        'query is ' +
                        namedVariable.variable.data.type.name +
                        ' instead of function');
                    continue
                }
                queryFunct.value = namedVariable.variable.data as FunctionData;
                break;
            case 'onload':
                if (namedVariable.variable.data.type.name !== 'function') {
                    AlertException(`onload should be a function but is ${namedVariable.variable.data.type.name}`);
                    continue
                }
                onloadFunct = namedVariable.variable.data as FunctionData;
                break;

            case 'table_row_model':
                if (namedVariable.variable.data.type.name !== 'function') {
                    AlertException(`table_row_model should be a function but is ${namedVariable.variable.data.type.name}`)
                    continue
                }
                optTableRowModel = namedVariable.variable.data as FunctionData
                break;
            
            case 'card_model':
                if (namedVariable.variable.data.type.name !== 'function') {
                    AlertException(`card_model should be a function but is ${namedVariable.variable.data.type.name}`)
                    continue
                }
                optCardModel = namedVariable.variable.data as FunctionData
                break;                

            case 'renumber_rows':
                if (namedVariable.variable.data.type.name !== 'function') {
                    AlertException(`renumber_rows should be a function but is ${namedVariable.variable.data.type.name}`)
                    continue
                }
                optRenumberRows = namedVariable.variable.data as FunctionData                
                break;

            case 'dbresult':
                if (namedVariable.variable.data.type.isPrimitive()) {
                    AlertException(
                        'dbresult is ' +
                        namedVariable.variable.data.type.name +
                        ' and should be an object'
                    );
                    continue
                }
                dbResult = namedVariable.variable.data as ObjectData;
                break;
            case 'entity':
                if (namedVariable.variable.data.type.name !== 'string') {
                    AlertException('entity should be a string');
                    continue
                }
                optEntity = (namedVariable.variable.data as PrimitiveData).value as string;
                break;
            case 'selected':
                optSelected.value = namedVariable.variable.data as ObjectData;
                break;
            case 'commands':
                optCommands = namedVariable.variable.data as ObjectData;
                optCmds = namedVariable.variable 
                break;
            case 'columns': 
                if (namedVariable.variable.data instanceof ObjectData)
                    optColumns = namedVariable.variable.data as ObjectData;
                else if (namedVariable.variable.data instanceof ObjectDataType)
                    optColumns = namedVariable.variable.data as ObjectDataType
                else throw 'optColumns is of type ' + namedVariable.variable.data.type.name
                break;
            case 'tablecommands':
                optTableCommands = namedVariable.variable.data as ObjectData;
                break;
        }
    };

    if (dbResult === undefined) {
        AlertException('dbresult has not been defined');
        throw 'dbresult should be defined by a calling component'
    }

    // dbResult validation

    const entities: string[] = [];
    let resultsetOk = false;
    let metaOk = false;
    dbResult.variables.forEach(({ name }) => {
        switch (name) {
            case 'resultset':
                resultsetOk = true;
                entities.push(name);
                break;
            case 'meta':
                metaOk = true;
                break;
            default:
                if (name !== undefined) entities.push(name);
        }
    });

    if (resultsetOk === false) logger.info('dbResult resultset is missing');
    if (metaOk === false) {
        AlertException('dbresult meta is missing')
        throw Error('dbresult meta is missing');
    }
    if (entities.length === 0) {
        AlertException('dbresult has no entity recordset');
        throw 'dbresult has no entity recordset';
    }

    if (optEntity === undefined && entities.length === 1) {
        optEntity = entities[0];
    }
    if (optEntity === undefined) {
        AlertException(
            'dbresult has ' +
            entities.length +
            ' entities, you have to choose one through entity option '
        );
        throw 'dbresult with several entities'
    }

    if (dbResult.variables.getVariable(optEntity) === undefined) {
        AlertException('entity ' + optEntity + ' not found');
        throw ' entity ' + optEntity + ' not found';
    }

    if (optSelected.value === undefined) {
        optSelected.value = new ObjectData(
            structure.objectDataType,
            new Tag(''),
            structure.scope
        );
    }

    if (optCommands === undefined) {
        optCommands = new ObjectData(structure.objectDataType, new Tag(''), structure.scope)
        // showTagError('commands option missing', optionsObject.tag)
        // throw 'commands option missing';
    }

    return {
        dbResult,
        optEntity,
        optCommands,
        optColumns,
        optTableCommands,
        optCmds,
        onloadFunct,
        optTableRowModel,
        optCardModel,
        optRenumberRows,
        optStyle
    };
}