import { Rule } from '@angular-devkit/schematics';
import { camelize, classify, dasherize } from '@angular-devkit/core/src/utils/strings';
import { importEnumsDescMap } from '../app-filterable/generate.gen';
import { 
  FormFieldType, 
  Validator,
  ModelRelation,
  ModelField,
  maskList,
  Model,
  fieldValidators,
  formFieldsAll,
  JavaFieldType,
  ClassRelationEnum
} from '@vmfvmf/ywtc-lib';
import { FrontEndGenerator } from '../../../shared/generator';
import { getModelById, getPrjSrd } from '../../../router.gen';
import { P3, P4, P5 } from '../../../router.map';

let imports: Set<string>;
let kraftosLibImports: Set<string>;

export function gen(model: Model): Rule {
  model = new Model(model);
  imports = new Set<string>();
  kraftosLibImports = new Set<string>();
  kraftosLibImports.add('AbstractField');

  const fieldsForFormable = [getFieldsForFormable(model.getAllFields())]
  .join(',\n');
  
  const relations = model!.relations;
  
  setFieldRelationGeneratorImport(model.getAllFields(), 
    new Model(model).getChildTables().map(rel => getModelById(rel.toModelId!)));
 
  const formable = 'GroupTabFormables';

  let constructorStr =  getChildTablesForms(formable, model);
  constructorStr = constructorStr.split('\n').length == 2 ? '' : constructorStr;

  importEnumsDescMap(model.fields, imports);

  const importsStr = Array.from(imports.values()).sort().join('\n');

  const childTables = new Model(model).getChildTables();
  const kraftosImpsStr = 'import {\n' + Array.from(kraftosLibImports).map(imp => `\t\t${imp}`).sort().join(',\n') + `\n} from '@vmfvmf/kraftos-lib';`;


  return new FrontEndGenerator(__filename).gen(
    {
      ...model, ...getPrjSrd(), importsStr, relations, 
      kraftosImpsStr, fieldsForFormable, childTables,
      formable, getTablesImports, constructorStr,
      dasherize
    });
}

function getChildTablesForms(formable: string, model: Model) {

  if (formable !== 'Formable') {
    kraftosLibImports = new Set([...Array.from(kraftosLibImports).filter(imp => imp !== 'Formable')]);
    kraftosLibImports.add(formable);
  }

  let constructorArr = new Array<string>('constructor() {');

  if (formable === 'GroupTabFormables') {
    const childForms = new Model(model).getChildForms().map((rel: ModelRelation) => getModelById(rel.toModelId!));

    let formGorups = `\t\tsuper([\n\t\t{entityName: '${model.name}', id: '${dasherize(model.name!)}-tab-form-id', title: '${model.menuTitle}'},\n\t\t` +
    childForms.map((childModel: Model) => {
      const fClassName = classify(childModel.name!);
      const fVarName = camelize(fClassName);
      const packName = dasherize(fClassName);
      imports.add(`import { Formable${fClassName} } from '../${packName}/app-formable-${packName}';`);
      return `\t{entityName: '${fVarName}', id: '${packName}-tab-form-id', title: '${childModel.menuTitle}', formable: new Formable${childModel.name}()}`;
    }).join(',\n\t\t') + '\n\t]);';
    constructorArr.push(formGorups);
  }
  model.getChildTables().forEach(child => {
    let nameDash = dasherize(child.toModelName!);
    imports.add(`import { Formable${child.toModelName} } from '../${nameDash}/app-formable-${nameDash}';`);
    imports.add(`import { Tableable${child.toModelName} } from '../${nameDash}/app-tableable-${nameDash}';`);
    constructorArr.push(`\tthis.addToTableMap('${child.name}', new Tableable${child.toModelName}(), new Formable${child.toModelName}().fieldsMap());`);
  });
  constructorArr.push('}');
  return constructorArr.join('\n');
}


function setFieldRelationGeneratorImport(fields: ModelField[], childTables: Model[], formFilter: string = 'Formable') {
  const isFormable = formFilter === 'Formable';

  fields.forEach(f => kraftosLibImports.add(formFieldsAll[f.formField!.type!].type + 'Field'));
  
  if (isFormable && fields.some(field => field.validatorOpts?.some(val => ['cpf', 'cnpj'].includes(val.value!)))) {
    fields.forEach(field => field
      .validatorOpts?.filter(val => ['cpf', 'cnpj'].includes(val.value!))
      .forEach(val => kraftosLibImports.add(val.value!.toUpperCase() + 'Validator')));
    fields.forEach(field => field
      .validatorOpts?.filter(val => fieldValidators[val.name!].kraftosImport)
      .forEach(val => kraftosLibImports.add(fieldValidators[val.name!].errorKey)));
  }
  
}

export function getTablesImports(childTables: Array<ModelRelation>) {
  let importsSet = new Set<string>();

  if (childTables[0]) {
    importsSet.add(`import { AppInjector } from 'src/app/app.module';`);
  }

  return Array.from(importsSet.values()).join('\n');
}

export function getFieldsForFormable(fields: Array<ModelField>, fildFilter: string = 'field', isFormable = true) {
  let completeDeclaration = new Array<string>();
  fields.forEach((field, idx) => {
      let declaration = new Array<string>();
      
      const nameField = field.enumDefName && !field.enumDefId && field.collection ? `${field.name!}Ids` : 
                        field.enumDefName && !field.enumDefId  ? `${field.name!}Id` : field.name!  ;

      declaration.push(`${P4}'${nameField}', new ${formFieldsAll[field.formField!.type!].type + 'Field'}({\n${P5}id: '${fildFilter}-${dasherize(nameField)}-id'`);
      
      field.formField!.rowN = field.formField!.rowN || Math.trunc(idx / 3);

      declaration.push(`${P5}rowNumber: ${field.formField!.rowN}`);
      if (field.formField!.colN) declaration.push(`${P5}colNumber: ${field.formField!.colN}`);
      
      const maskValidator = field.validatorOpts?.find(f => f.name === 'Mask');
      if (maskValidator) {
        let maskObj = maskList[maskValidator.value!];
        declaration.push(`${P5}mask: '${maskObj.mask}'`);
      }

      if (isFormable) {
        const vals = addValidators(field.validatorOpts)
        if (vals) declaration.push(vals);
      }

      declaration.push(`${P5}label: '${field.label}'`);
      
      if ([FormFieldType.SELECT, FormFieldType.AUTO_COMPLETE, FormFieldType.MULTSELECT, FormFieldType.MULTCHECK, FormFieldType.MULTAUTOCOMPLETE]
          .includes(field.formField!.type!)) {
            let name = field.enumDefName || field.name;
            if (field.javaType === JavaFieldType.Long) { // its a relation
              imports.add(`import { environment } from 'src/environments/environment';`);
              declaration.push(`${P5}optionsSrc: {api: environment.endpoints.${camelize(field.enumDefName!)}}`);
            } else {
              declaration.push(`${P5}optionsSrc: ${ getOptionsSrc(field, name!) }`);
            }
          }

      // if (field.ngIf) declaration.push(`${P5}ngIf: ${field.ngIf}`);

      completeDeclaration.push(`${P3}[\n${declaration.join(',\n')}\n${P4}})\n${P3}]`);
  });

  return completeDeclaration.join(',\n');
}

function addValidators(validators: Validator[]) {
  if (!validators || validators.length < 1) {
    return '';
  }

  if (validators.some(v => ['NotNull', 'NotEmpty','MaxLength', 'MinLength', 'Min', 'Max'].includes(v.name!))) {
    imports.add(`import { Validators } from '@angular/forms';`);
  }

  return `${P5}validatorOpts: [\n` + validators.map(v => {
    const valer = fieldValidators[v.name!];
    let returnArr = new Array<string>();

    if (['cpf', 'cnpj', 'cpfcnpj'].includes(v.value!)) {
      let maskObj = maskList[v.value!];
      returnArr.push(`validator: ${v.value!.toUpperCase()}Validator`);
      returnArr.push(`errorKey: '${maskObj.errorKey}'`);
    } else if (Object.values(maskList).map(m => m.name).includes(v.value!)) {
      let maskObj = maskList[v.value!];      
      returnArr.push(`errorKey: '${maskObj.errorKey}'`);
    } else if (['MaxLength', 'MinLength', 'Min', 'Max'].includes(v.name!)){
      returnArr.push(`validator: Validators.${camelize(v.name!)}(${v.value!})`);
      returnArr.push(`errorKey: '${valer.errorKey}'`);
    } else if (['NotNull', 'NotEmpty'].includes(v.name!)) {
      returnArr.push(`validator: Validators.required`);
      returnArr.push(`errorKey: 'required'`);
    } else if (['Date', 'MinSize', 'MaxSize'].includes(v.name!)) {
      const fvalidator = fieldValidators[v.name!];
      kraftosLibImports.add(fvalidator.errorKey);
      const val = v.name! === 'Date' ? `'${v.value!}'` : v.value!;
      returnArr.push(`validator: ${fvalidator.errorKey}(${val})`);
      returnArr.push(`errorKey: '${valer.errorKey}'`);
    }
    returnArr.push(`errorMsg: '${v.errorMsg?.replace('${1}', v.value!)}'`);

    return P3+P3+'{' + returnArr.join(', ') + '}';
  }
  ).join(',\n') +
    `\n${P5}]`;
}


function getOptionsSrc(field: ModelField, name: string) {
  // TODO fix
  // if ((field.modelProp as any).relation) {
  //   imports.add(`import { environment } from 'src/environments/environment';`);
  //   return '{ api: environment.endpoints.' + camelize(name) + ' }';
  // }
  return camelize(name) + 'DescMap';
}

export function withTables(childTables: Array<Model>) {
  if (childTables.length > 0)
  return 'WithTables';
  return '';
}