import { Rule } from '@angular-devkit/schematics';
import { Model, JavaFieldType, ClassRelationEnum, Validator, maskList } from '@vmfvmf/ywtc-lib';
import { BackEndGenerator } from '../../../shared/generator';
import { getPrjSrd } from '../../../router.gen';
import { camelize } from '@angular-devkit/core/src/utils/strings';

let imports: Set<string>;

export function gen(model: Model): Rule {  
  imports = new Set();

  const allFieldsStr =  getFieldsStr(model);
  const importsStr = Array.from(imports).sort().join('\n');
  
  return new BackEndGenerator(__filename).gen({...model, ...getPrjSrd(), importsStr, allFieldsStr });
}


function getFieldsStr(model: Model) {
  return [modelFields(model), relationFields(model)].filter(f => f).join(',\n')
}

function relationFields(model: Model) {
  const result1 = model.relations
  .filter(rel => rel.relation !== ClassRelationEnum.ManyToMany)
  .map(rel => {
    var classPackN = camelize(rel.toModelName).toLowerCase();
    imports.add(`${getPrjSrd().prjImpBse}.backend.${classPackN}.${rel.toModelName}Dto;`);
    if ((rel.relation).endsWith('Many')) {
      imports.add(`import java.util.List;`);
      return `List<${rel.toModelName}Dto> ${rel.name}`;
    } else if (rel.relation === ClassRelationEnum.ManyToOne) {
      return `Long ${rel.name}Id`;
    } else {
      return `${rel.toModelName}Dto ${rel.name}`;
    }  
  }).map(s => `\t${s}`).join(',\n');

  const result2 = model.relations
  .filter(rel => rel.relation === ClassRelationEnum.ManyToMany)
  .map(rel => {
    imports.add(`import java.util.List;`);
    return `\tList<Long> ${rel.name}Ids`;
  })
  .join(',\n');

  return [result1, result2].filter(r => r).join(',\n')
}

export function modelFields(model: Model) {
  
  var fildsSet = new Set(['Long id', 'Integer version']);
  model.fields.forEach(field => {
    
    let javaType = field.javaType.toString();
    if (field.javaType === JavaFieldType.Enum) {
      imports.add(`${getPrjSrd().prjImpBse}.backend.enums.${field.enumDefName};`);
      javaType = field.enumDefName;

    } else if ([JavaFieldType.LocalDate, JavaFieldType.LocalDateTime].includes(field.javaType)) {
      imports.add(`import java.time.${field.javaType};`);
    } else if (field.javaType == JavaFieldType.BigDecimal) {
      imports.add('import java.math.BigDecimal;');
    }
   
    if (field.collection) {
      javaType = `List<${javaType}>`;
      imports.add('import java.util.List;');
    }

    let validationArr = new Array<string>();

    if (field.validatorOpts?.length > 0) {
      field.validatorOpts
      .filter(val => !['AssertBoolean'].includes(val.name))
      .forEach(val => {
        let name = getValidatorName(val);
        imports.add(`import jakarta.validation.constraints.${name};`);
        
        validationArr.push(`@${name}(message = "${val.errorMsg.replace('${1}', val.value)}"${getValidationValue(val)})`);
      })
    }

    fildsSet.add(`${validationArr.join(' ')}\n\t${javaType} ${field.name}`);
  });
  return Array.from(fildsSet).map(s => `\t${s}`).join(',\n');
}

function getValidatorName(val: Validator) {
  if(val.name == 'Date') return val.value;
  if(val.name == 'MaxLength' || val.name == 'MinLength') return 'Size';
  if(val.name == 'Mask'  && maskList[val.value]) return 'Pattern';
  if(val.name == 'Regex') return 'Pattern';
  return val.name;
}

function getValidationValue(val: Validator) {
  if (!val.value || val.name == 'Date') return '';

  if (val.name == 'MaxLength') {
    return `, max = ${val.value}`;
  } 
  if (val.name == 'MinLength') {
    return `, min = ${val.value}`;
  } 
  if (val.name == 'Mask' && maskList[val.value]) {
    return `, regexp = "${maskList[val.value].regex}"`;
  } 
  if (val.name === 'Regex' ) {
    return `, regexp = "${val.value}"`;
  } 
  return  `, value = ${val.value}`;
}