import { Rule } from '@angular-devkit/schematics';

import { 
  ClassRelationEnum, 
  AngularFieldType, 
  JavaFieldType, 
  Model, 
  ModelField, 
  ModelRelation
} from '@vmfvmf/ywtc-lib';

import { camelize, classify, underscore } from '@angular-devkit/core/src/utils/strings';
import { BackEndGenerator } from '../../../shared/generator';
import { getPrjSrd, getRelationById } from '../../../router.gen';
import { P2 } from '../../../router.map';

let imports: Set<string>;

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

  const entityRelationFields = relationFields(model);

  const mysqlSetsToStrExample = getMysqlSetToStr(model);

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

  const allFieldsStr = [fieldsStr, entityRelationFields, mysqlSetsToStrExample].filter(n => n).join('\n\n');

  return new BackEndGenerator(__filename).gen({ ...model, ...getPrjSrd(), importsStr, allFieldsStr, mysqlSetsToStrExample });
}

function getMysqlSetToStr(model: Model) {
  model.fields.filter((f: ModelField) => f.angularType === AngularFieldType.ENUM && f.collection)
    .map((f: ModelField) => {
    imports.add('import org.springframework.data.domain.Example;');
    imports.add('import org.springframework.data.domain.ExampleMatcher;');
    const fieldName = camelize(f.name!);
    return `\t@Override
\tpublic Example getExample() {
${P2}return Example.of(this, ExampleMatcher.matching().withMatcher("${fieldName}", m -> m.contains()));
\t}`
}).join('\n\n');
}

function relationFields(model: Model) {
  return model.relations
    .map((rel: ModelRelation) => {
      let ret: string[] = [];
    
      const mdlNUndes = underscore(model.name);
      const toMdlNUndes = underscore(rel.toModelName);
    
      imports.add(`${getPrjSrd().prjImpBse}.backend.${camelize(rel.toModelName)}.${classify(rel.toModelName)};`);
      imports.add(`import jakarta.persistence.${rel.relation};`);
      imports.add(`import jakarta.persistence.JoinColumn;`);
    
      if ([ClassRelationEnum.OneToOne].includes(rel.relation)) {
        imports.add(`import jakarta.persistence.CascadeType;`);
        ret.push(`@JoinColumn(name = "${underscore(rel.toModelName)}_id", referencedColumnName = "id")`);
        ret.push(`@OneToOne(cascade = CascadeType.ALL, orphanRemoval = true)`);
      
      } else if ([ClassRelationEnum.OneToMany].includes(rel.relation)) {
        imports.add(`import jakarta.persistence.CascadeType;`);
        ret.push(`@JoinColumn(name = "${mdlNUndes}_id", nullable = false)`);
        ret.push(`@OneToMany(cascade = CascadeType.ALL, orphanRemoval = true)`);
      } else if ([ClassRelationEnum.ManyToOne].includes(rel.relation)) {
        ret.push(`@JoinColumn(name = "${toMdlNUndes}_id", nullable = false)`);
        ret.push(`@ManyToOne`);
      } else if ([ClassRelationEnum.ManyToMany].includes(rel.relation)) {
        imports.add(`import jakarta.persistence.JoinTable;`);
        imports.add(`import jakarta.persistence.CascadeType;`);
        ret.push(`@ManyToMany`);
        ret.push(
          `@JoinTable(`, 
          `\tname = "rel_${mdlNUndes}_${toMdlNUndes}",`,
          `\tjoinColumns = @JoinColumn(name = "${mdlNUndes}_id"),`,
          `\tinverseJoinColumns = @JoinColumn(name = "${toMdlNUndes}_id"))`);
      
      }
    
      if ((rel.relation as string).endsWith('Many')) {
        imports.add(`import java.util.List;`);
        ret.push(`private List<${rel.toModelName}> ${rel.name};`);
      } else {
        ret.push(`private ${rel.toModelName} ${rel.name};`);
      }
      return ret.map(s => `\t${s}`).join('\n');

    }).join('\n\n')
}

export function modelFields(model: Model) {
  return model.fields.map((field: ModelField) => {
    var fildsSet = new Set();
    imports.add('import jakarta.persistence.Column;')

    var length =  field.javaType === JavaFieldType.String ? `, length = ${new ModelField(field).getColLength()}` : '';
    var longText = field.colLongText ? 'columnDefinition = "TEXT", ' : '';
    fildsSet.add(`@Column(${longText}nullable = ${!new ModelField(field).getColNullable()}${length})`)
    
    let javaType = field.javaType.toString();
    if (field.javaType === JavaFieldType.Enum && !field.collection) {
      javaType = field.enumDefName ;
      imports.add(`${getPrjSrd().prjImpBse}.backend.enums.${field.enumDefName};`);
      imports.add('import jakarta.persistence.Enumerated;');
      imports.add('import jakarta.persistence.EnumType;');
      fildsSet.add(`@Enumerated(EnumType.STRING)`);

    } else if ([JavaFieldType.LocalDate, JavaFieldType.LocalDateTime].includes(field.javaType)) {
      imports.add(`import java.time.${field.javaType};`);
    } else if (field.enumDefId) {
      javaType = 'String';
    } else if (field.javaType == JavaFieldType.BigDecimal) {
      imports.add('import java.math.BigDecimal;');
    }
    if (longText) {
      fildsSet.add(`@Lob`);
    }
    
    if (field.collection && !field.enumDefId) {
      javaType = `List<${javaType}>`;
      imports.add('import java.util.List;');
    } 
    fildsSet.add(`private ${javaType} ${field.name};`)
    return Array.from(fildsSet).map(s => `\t${s}`).join('\n');
  }).join('\n\n');
}