import { Rule, SchematicContext, Tree, chain, schematic } from "@angular-devkit/schematics";
import { EnumDef, IEnumDef, IModel, Model, ModelRelation, Project } from "@vmfvmf/ywtc-lib";
import { getEnumByIdFromKraftosApi, getEnumsFromKraftosApi, getModelFromKraftosApi, getModelRelationFromKraftosApi, getModelsFromKraftosApi, getProjectFromKraftos } from "./shared/kraftos-api";
import { camelize, capitalize, classify, dasherize, underscore } from "@angular-devkit/core/src/utils/strings";
import { routerRequiredParamMap } from "./router.map";

var _project: Project = undefined;
var _enums:EnumDef[] = undefined;
var _models: Model[] = undefined;
var _prjShared: IPrjShared = undefined;

export function getProject() {
 return _project;
}

export function getModels(): Model[] {
  return _models;
}

export function getModelById(modelId: number): Model {
  return new Model(_models.find(m => m.id === modelId));
}

export function getRelationById(relationId: number): ModelRelation {
  return _models.map(m => m.relations.find(rel => rel.id === relationId))[0];
}

export function getEnums() {
  return _enums;
}

export function getEnumById(enumDefId: number): EnumDef {
  return _enums.find(en => en.id === enumDefId);
}

export function getPrjSrd() {
  return _prjShared;
}

export function setProject(prj: Project) {
  _project = prj;
  _prjShared = {   
    dbName: prj.config.databaseConfig.dbName,
    artifactId: prj.config.sharedConfig.artifactId,
    groupId: prj.config.sharedConfig.groupId,
    grpArtfId: `${prj.config.sharedConfig.groupId}.${prj.config.sharedConfig.artifactId}`,
    prjImpBse: `import ${prj.config.sharedConfig.groupId}.${prj.config.sharedConfig.artifactId}`,
    prjNClasd: classify(prj.name), 
    prjNDashd: dasherize(prj.name),
    prjNCamld: camelize(prj.name),
    prjNUndes: underscore(prj.name),
    prjNFrmal: dasherize(prj.name).split('-').map(capitalize).join(" ")
  };
}

export interface IPrjShared {
  dbName: string;
  artifactId: string;
  groupId: string;
  grpArtfId: string;
  prjImpBse: string;
  prjNClasd: string;
  prjNDashd: string;
  prjNCamld: string;
  prjNUndes: string;
  prjNFrmal: string;

  ucNo?: string;

  mdlNPack?: string;
  mdlNClasd?: string;
  mdlNDashd?: string;
  mdlNCamld?: string;
  mdlNUprCd?: string;
  mdlNUndes?: string;
  mdlNUndUp?: string;
  mdlNFrmal?: string;

  enmNPack?: string;
  enmNClasd?: string;
  enmNDashd?: string;
  enmNCamld?: string;
  enmNUndes?: string;
  enmNFrmal?: string;
}

var _model: Model;

export function setModel(m: IModel) {
 _model = new Model(m);
 var modelName = m.name;
 _prjShared = { 
    ..._prjShared,
    ucNo: m.ucNo,
    mdlNPack: modelName.toLocaleLowerCase(),
    mdlNClasd: classify(modelName), 
    mdlNDashd: dasherize(modelName),
    mdlNCamld: camelize(modelName),
    mdlNUprCd: modelName.toUpperCase(),
    mdlNUndes: underscore(modelName),
    mdlNUndUp: underscore(modelName).toUpperCase(),
    mdlNFrmal: dasherize(modelName).split('-').map(capitalize).join(" "),
  }
}

export function getModel() {
  return _model;
}

var _enumDef: EnumDef;

export function setEnumDef(e: EnumDef) {
  _enumDef = e;
  var enumDefName = e.name;
  _prjShared = { 
    ..._prjShared,
    enmNPack: enumDefName.toLocaleLowerCase(),
    enmNClasd: classify(enumDefName), 
    enmNDashd: dasherize(enumDefName),
    enmNCamld: camelize(enumDefName),
    enmNUndes: underscore(enumDefName),
    enmNFrmal: dasherize(enumDefName).split('-').map(capitalize).join(" ")
  }
}

export function getEnumDef() {
  return _enumDef;
}

export function gen(config: IRouterConfig): Rule {
  return async (tree: Tree, context: SchematicContext) => {
    
    var requiredParam = routerRequiredParamMap.get(config.schema);
    if (config[requiredParam] == null) {
      throw Error(`For the generator ${config.schema}, the param ${routerRequiredParamMap.get(config.schema)} is mandatory! `);
    }

    var obj: any | EnumDef | Model | ModelRelation;

    if (config.modelid) {
      obj = await getModelFromKraftosApi(config.modelid);
      config.prjid = obj.projectId;
    } else if (config.enumdefid) {
      obj = await getEnumByIdFromKraftosApi(config.enumdefid);
      obj.options = JSON.parse(obj.optionsJson);
      config.prjid = obj.projectId;
    } else if (config.modelrelid) {
      obj = await getModelRelationFromKraftosApi(config.modelrelid);
      var obj2 = await getModelFromKraftosApi(obj.modelId);
      config.prjid = obj2.projectId;
    }

    await loadProject(config.prjid)
    obj = obj === undefined ?  getProject(): obj;
    _enums.forEach(e => e.options = JSON.parse(e.optionsJson));

    if (config.modelrelid) {
    }
    if (config.modelid) {
      setModel(obj);      
    } else if (config.enumdefid) {
      setEnumDef(obj);   
    }

    return <Rule>chain([schematic(config.schema, obj)])(tree, context);
  };
}

async function loadProject(prjId: number) {
  setProject(await getProjectFromKraftos(prjId));
  _enums = await getEnumsFromKraftosApi(prjId);
  _models = (await getModelsFromKraftosApi(prjId)).map(m => new Model(m));
}

export interface IRouterConfig {
  prjid: number;
  modelid: number;
  enumdefid: number;
  modelrelid: number;
  schema: string;
}