import { dasherize, camelize } from '@angular-devkit/core/src/utils/strings';
import { Rule, SchematicContext, Tree } from '@angular-devkit/schematics';
import { AngularFieldType, ModelField, Model, getImportForFormFieldE2E, formFieldsAll } from '@vmfvmf/ywtc-lib';
import { getPrjSrd } from '../../../../router.gen';
import { E2EGenerator } from '../../../../shared/generator';
import { P3 } from '../../../../router.map';

let enumDescMapsImports: Set<string>;

export function gen(model: Model): Rule {
  return (tree: Tree, _context: SchematicContext) => {   
    enumDescMapsImports = new Set();
    
    const pageElementImportsStr = Array.from(new Set(model.getFilters().map(getPageElementImport)).values()).join('\n') ;
    const filtersDeclarationStr = model.getFilters().map(getFilterDeclaration).join(',\n');

    const extraOpts = getExtraOpts();
    
    const headers = model.getColumns().map((f: ModelField) => `${f.label}'`);
    
    const searchTableId = (model.name.toLocaleLowerCase() || 'default') + '-table-id';
    
    const paginator = true;

    const tableDeclarationStr = getTableDeclaration(model, getPrjSrd().mdlNClasd!);

    const importPipeTransform = model.getColumns().some((field: ModelField) => 
      ([AngularFieldType.DATE].includes(field.angularType)) ||
      (field.angularType === 'STRING' && field.validatorOpts.some(f => f.mask))
    ) ? "\nimport { pipeTransform } from 'cypress/support/utils/pipe-transform';" : '';

    const enumsDescMapDeclarationsStr = Array.from(enumDescMapsImports.values())
      .map((v: string) => `import { ${v}DescMap } from 'src/app/${getPrjSrd().prjNDashd}-frontend/enums/${dasherize(v)}';`)
      .join('\n');

    const filtersNames = model.getFilters().map((field: ModelField) => `${P3}${getPrjSrd().mdlNCamld}Filters.${field.name}`).join(',\n')

    return new E2EGenerator(__filename).gen({ headers, ...getPrjSrd(), importPipeTransform, searchTableId,
       tableDeclarationStr, 
      extraOpts, pageElementImportsStr, filtersDeclarationStr,
      enumsDescMapDeclarationsStr, paginator, filtersNames });
  };
}

function getTableDeclaration(tableable: Model, modelName: string) {
  let opts = new Array<string>();
  opts.push(`\t\tid: '#${camelize(tableable.name)}-table-id'`);

  let  actionColHeader = "'', ";

  opts.push(`\t\theaderTexts: [ ${actionColHeader + tableable.getColumns().map((col: ModelField) => `'${col.label}'`).join(',')}]`);
  
  opts.push('\t\tupdateDeleteControl: true');
  
  opts.push('\t\tpaginator: true');
  
  opts.push(`\t\tinitialData: ${modelName.toUpperCase()}_FACTORY.SEARCH_POOL`)

  let interfaceRowCOnverter = `\t\tinterfaceToRowConverter: (i${modelName}: I${modelName}): string[] =>`;

  const columns = tableable.getColumns().map((col: ModelField) => getColumnDeclaration(col, modelName));
  opts.push(`${interfaceRowCOnverter}\n${P3}['', ${columns.join(', ')}]`)

  return '\tnew PageElementTable({\n' + opts.join(',\n') + '\n\t})';
}

export function getColumnDeclaration(colModel: ModelField, modelName: string) {
  if ([AngularFieldType.DATE].includes(colModel.angularType)) {
    return `pipeTransform.date(i${modelName}.${colModel.name}!, '${colModel.showFormatMask}')`;
  } else if (colModel.angularType === 'STRING' && colModel.showFormatMask) {
    return `pipeTransform.${colModel.showFormatMask.toLowerCase()}(i${modelName}.${colModel.name}!)`;
  } else if (colModel.angularType === 'ENUM') {
    enumDescMapsImports.add(`${camelize(colModel.enumDefName)}`);
    if (colModel.collection) {
      return `i${modelName}.${colModel.name}!.map(p => ${camelize(colModel.enumDefName)}DescMap.get(p!)).join(', ')`;
    }
    return `${camelize(colModel.enumDefName)}DescMap.get(i${modelName}.${colModel.name}!)!`;
  }
  return `i${modelName}.${colModel.name}!`;
}

function getPageElementImport(field: ModelField) {
  const e2eType = formFieldsAll[field.formField!.type!].e2e;
  return getImportForFormFieldE2E(e2eType, dasherize(e2eType));
}

function getExtraOpts() {
  let opts = new Array<string>();

  opts.push('\t\tupdateDeleteControl: true');
  opts.push('\t\tpaginator: true');

  return ',\n' + opts.join(',\n');
}

export function getFilterDeclaration(field: ModelField) {
  const typeE2e = formFieldsAll[field.formField.type].e2e;
  let declaration = `${field.name}: new ${typeE2e}({`;

  let opts: Array<string> = [];

  opts.push(`\t\t\tid: '#filter-${dasherize(field.name)}-id'`);

  if (field.label) {
    opts.push(`\t\t\tlabel: '${field.label}'`);
  }
  
  if (field.defaultValue) {
    opts.push(`\t\t\tdefaultValue: '${field.defaultValue}'`);
  }

  if (field.formField.rowN) {
    opts.push(`\t\t\trowN: '${field.formField.rowN}'`);
  }
  
  if (field.formField.colN) {
    opts.push(`\t\t\tcolN: '${field.formField.colN}'`);
  }

  if (field.enumDefId) {
    const enumName = camelize(field.enumDefName);
    enumDescMapsImports.add(`${enumName}`);
    opts.push(`\t\t\toptions: Array.from(${enumName}DescMap.values())`);
  }

  opts.push(`\t\t\tentityPropertyName: '${field.name}'`)

  return `\t\t${declaration}\n${opts.join(',\n')}\n\t\t})`;
}