import { Rule, SchematicContext, Tree } from '@angular-devkit/schematics';
import { ModelField,  ModelRelation, Model, ClassRelationEnum } from '@vmfvmf/ywtc-lib';
import { camelize, classify, dasherize } from '@angular-devkit/core/src/utils/strings';
import { getColumnDeclaration } from '../search-page/generate.gen';
import { formFieldsAll, getImportForFormFieldE2E } from '@vmfvmf/ywtc-lib/dist/model.maps';
import { getModelById, getPrjSrd } from '../../../../router.gen';
import { E2EGenerator } from '../../../../shared/generator';
import { P3, P4, P5 } from '../../../../router.map';

let imports: Set<string>;

export function getImport() { return imports; }
export function setImport(imp: Set<string>) { imports =  imp; }

export function gen(model: Model): Rule {
  model = new Model(model);
  return async (tree: Tree, _context: SchematicContext) => { 
    setImport(new Set());
    const columnsFieldNameMap = new Map<string, string>();
        
    const tablesDeclarationStr = model.relations
      .filter(rel => rel.relation === ClassRelationEnum.OneToMany)
      .map(getChildTableDeclaration).join(',\n');
      
    model.fields
      .forEach((f: ModelField)  => columnsFieldNameMap.set(dasherize(f.name).replace('-', '_'), f.name));
    
    let updatePageStructType = '', formfieldsNames = '', tablesNames = '', 
    updatePageType = 'PageObjectUpdateEntity',
    importUpdPageType = `import { PageObjectUpdateEntity } from 'cypress/support/test-structure/page-object/page-object-update-entity';`;

    if (model.getChildForms() && model.getChildForms()[0]) { // groupTabFroms
      updatePageStructType = 'UpdatePageTabGroupStruct';
      imports.add("import { UpdatePageTabGroupStruct } from 'cypress/support/test-structure/page-object/i-page-structure';");
      imports.add("import { PageElementTable } from 'cypress/support/test-structure/page-element/page-element-table';");
      formfieldsNames = addGroupFormFields(model);
      updatePageType = 'PageObjectUpdateEntityTabForms';
      importUpdPageType = `import { PageObjectUpdateEntityTabForms } from 'cypress/support/test-structure/page-object/page-object-update-entity-tab-forms';`;
    } else {
      updatePageStructType = 'UpdatePageStruct';
      imports.add("import { UpdatePageStruct } from 'cypress/support/test-structure/page-object/i-page-structure';");      
      formfieldsNames = addFormFields(model);
    }

    if (model.getChildTables()) {
      imports.add("import { PageElementTable } from 'cypress/support/test-structure/page-element/page-element-table';");
      imports.add("import { pipeTransform } from 'cypress/support/utils/pipe-transform';");
      tablesNames = '\tchildTables: [\n\t\t' + model.getChildTables()
        .map((rel: ModelRelation) => `${P3}${getPrjSrd().mdlNCamld}ChildTables.${rel.toModelName}`).join(',\n') +
        '\n\t]';  
      
    }

    addImports(model);

    const bodyStr = [formfieldsNames, tablesNames].filter(f => f).join(',\n');
    const entitiesformFields = addEntitiesFormFields(model);
    const importStr = Array.from(imports).sort().join("\n");

    return new E2EGenerator(__filename).gen({tablesDeclarationStr, entitiesformFields, importUpdPageType,
      importStr, columnsFieldNameMap, ...getPrjSrd(), bodyStr, updatePageStructType, updatePageType
       });
  }; 
}

function addFormFields(model: Model) {
  return '\tformFields: [\n\t\t' +  model.fields
      .map((field: ModelField) => `${P3}${getPrjSrd().mdlNCamld}FormFields.${field.name}`).join(',\n')
      + '\n\t]';
}

function addGroupFormFields(model: Model) {
  let ret = new Array<string>();
  ret.push(
    '\n\ttabGroupForms: {', 
    '\t\tid: "#update-page-tab-group-id",',
    '\t\ttabs:[',
    `${P3}{`,
    `${P4}id: '#${dasherize(model.name)}-tab-form-id',`,
    `${P4}title: '${model.menuTitle}',`,
    `${P4}propertyName: '${camelize(model.name)}',`,
    `${P4}form: [`,
    model.getAllFields().map(f => `${P5}${camelize(model.name)}FormFields.${f.name}`).join(',\n'),
    `${P4}]`,
    `${P3}},`,
  );

  model.getChildForms().forEach(child => {
    const childModel = getModelById(child.toModelId);
    ret.push(
    `${P3}{`,
    `${P4}id: '#${dasherize(child.toModelName)}-tab-form-id',`,
    `${P4}title: '${childModel.menuTitle}',`,
    `${P4}propertyName: '${child.name}',`,
    `${P4}form: [`,
    childModel.getAllFields().map(f => `${P5}${camelize(child.toModelName)}FormFields.${f.name}`).join(',\n'),
    `${P4}]`,
    `${P3}},`,
    );
  });

  ret.push('\t\t]');
  ret.push('\t}');
  
  return ret.join('\n');
}

export function addEntitiesFormFields(model: Model) {
  let fieldsStr = `\texport const ${camelize(model.name)}FormFields = {\n\t\t${model.getAllFields().map(getFieldDeclaration).join(',\n')}};\n\n`;

  fieldsStr += model.getChildForms()
  .map(child => `\texport const ${camelize(child.toModelName)}FormFields = {${getModelById(child.toModelId).getAllFields().map(getFieldDeclaration).join(',\n')}}`)
  .join('\n\n');

  return fieldsStr;
}

;
function addImports(model: Model) {
   model.relations.filter(rel => rel.relation === ClassRelationEnum.OneToMany)
    .map((rel: ModelRelation) => `import { I${classify(rel.toModelName)} } from 'src/app/${getPrjSrd().prjNDashd}-frontend/${dasherize(rel.toModelName)}/${dasherize(rel.toModelName)}';`)
    .forEach(str => imports.add(str));

  model.getAllFields().map(getFormFieldsImports);

  if (model.relations
    .some((rel: ModelRelation) => getModelById(rel.toModelId).fields.filter(f => f.formField.columnable).some(f => f.validatorOpts.some(v => v.mask)))) {
      imports.add(`import { pipeTransform } from 'cypress/support/utils/pipe-transform';`);

    }

    addEnumImports(model);

    model.relations
      .map((rel: ModelRelation) => getModelById(rel.toModelId).fields.filter(f => f.formField.columnable)
          .filter(f => f.angularType === 'ENUM')
          .map(f => `import { ${camelize(f.name)}DescMap } from 'src/app/${getPrjSrd().prjNDashd}-frontend/enums/${dasherize(f.name)}';`)
          .forEach(imp=> imports.add(imp))
      );

    if (model.relations.filter(rel => rel.relation === ClassRelationEnum.OneToMany).length === 0) {
      imports.add(`import { PageElementTable } from 'cypress/support/test-structure/page-element/page-element-table';`);

    }
}


export function addEnumImports(model: Model) {
  model.fields
      .filter((f: ModelField) => f.angularType == 'ENUM')
      .map((f: ModelField) => `import { ${camelize(f.enumDefName)}DescMap } from 'src/app/${getPrjSrd().prjNDashd}-frontend/enums/${dasherize(f.enumDefName)}';`)
      .forEach(imp => imports.add(imp));
}

export function getFormFieldsImports(f: ModelField) {
  const e2e = formFieldsAll[f.formField.type].e2e;
  imports.add(getImportForFormFieldE2E(e2e, dasherize(e2e)));
}

function getChildTableDeclaration(rel: ModelRelation) {
  const childModel = getModelById(rel.toModelId);
  let opts = new Array<string>();
  opts.push(`\t\tid: '#${camelize(rel.toModelName || 'default')}-table-id'`);

  let  actionColHeader = "'', ";
  // const cols = 
  opts.push(`\t\theaderTexts: [ ${actionColHeader + childModel.getColumns().map(f => `'${f.label}'`).join(',')}]`);
  
  opts.push('\t\tupdateDeleteControl: true');
  
  opts.push('\t\tpaginator: true');
  
  opts.push('\t\tinitialData: []');

  const modelName = classify(rel.toModelName);

  let interfaceRowCOnverter = `\t\tinterfaceToRowConverter: (i${modelName}: I${modelName}): string[] =>`;
  const updateDeleteControlStr = `'', `;
  const columns = childModel.getColumns().map(f=> getColumnDeclaration(f, modelName));
  opts.push(`${interfaceRowCOnverter}\n${P3}[${updateDeleteControlStr}${columns.join(', ')}]`)

  return `\t${rel.toModelName}: new PageElementTable({\n${opts.join(',\n')}\n\t})`;
}

export function getFieldDeclaration(field: ModelField) {
  const formFieldType = formFieldsAll[field.formField.type]!.e2e;

  imports.add(`import { ${formFieldType} } from 'cypress/support/test-structure/form-field/${dasherize(formFieldType)}';`);

  let declaration = `${field.name}: new ${formFieldType}({`;

  let opts: Array<string> = [];

  opts.push(`${P3}id: '#field-${dasherize(field.name)}-id'`);

  if (field.label) {
    opts.push(`${P3}label: '${field.label}'`);
  }
  
  if (field.defaultValue) {
    opts.push(`${P3}defaultValue: '${field.defaultValue}'`);
  }

  if (field.formField.rowN) {
    opts.push(`${P3}rowN: '${field.formField.rowN}'`);
  }
  
  if (field.formField.colN) {
    opts.push(`${P3}colN: '${field.formField.colN}'`);
  }

  // if (field.modelProp.classType) {
  //   opts.push(`optionsSrc: '${field.colNumber}'`);
  // }

  if (field.enumDefId) {
    opts.push(`${P3}options: Array.from(${camelize(field.enumDefName)}DescMap.values())`);
  }

  opts.push(`${P3}entityPropertyName: '${field.name}'`);

  if (formFieldType?.startsWith('PageElementMult')) {
    if (field.enumDefId) {
      const optionsDescMap = `${camelize(field.enumDefName)}DescMap`;
      opts.push(`${P3}optionsDescMap: ${optionsDescMap}`);
    } else {
      // const hlp = field.name[0];
      // const model = getModelById(field.toModelId);
      // const nameToUpper = dasherize(model.name).replace('-', '_').toUpperCase();
      // const propName = model.fields[0].name;
      // opts.push(`${P3}options: ${nameToUpper}_FACTORY.SEARCH_POOL.map(${hlp} => ${hlp}.${propName}!)`);
      // opts.push(`${P3}optionsDescFunc: (${hlp}: any) => ${hlp} ? ${hlp}.${propName} : ''`);
    }

  }

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

export function importEnums(fields: Array<ModelField>) {
  return fields
    .filter(f => f.angularType == 'ENUM')
    .map(f => `import { ${f.enumDefName} } from 'src/app/demo-frontend/enums/${dasherize(f.enumDefName)}';`)
}