import { Interface, CodeGenerator, FileStructures as PontFileStructures } from "pont-engine";
import { reviseModName } from "pont-engine/lib/utils";

export class FileStructures extends PontFileStructures {
  getDataSourcesTs() {
    const dsNames = this.getMultipleOriginsDataSourceName();
    return `
      ${dsNames
        .map((name) => {
          return `export { defs as ${name}Defs, ${name} } from './${name}';
          `;
        })
        .join("\n")}
    `;
  }
}
export default class MyGenerator extends CodeGenerator {
  private originDataSourceName = "";
  setDataSource(dataSource: any) {
    if (!this.originDataSourceName) {
      this.originDataSourceName = dataSource.name;
    }
    CodeGenerator.prototype.setDataSource.call(this, dataSource);
  }
  getBaseClassesIndex() {
    const clsCodes = this.dataSource.baseClasses.map((base) => {
      const interfaceName = base.templateArgs.length
        ? `${base.name}<T0 = {}>`
        : base.name;
      return `export interface ${interfaceName} {
          ${base.properties
            .map((prop) => {
              return prop
                .toPropertyCode()
                .replace(`defs.${base.getDsName()}.`, "");
            })
            .filter((id) => id)
            .join("\n")}
        }
      `;
    });
    return `
      export type ObjectMap<Key extends string | number | symbol = any, Value = any> = {
        [key in Key]: Value;
      }
      ${clsCodes.join("\n")}`;
  }

  getIndex() {
    const file = `import * as defs from './baseClass';
    export { default as ${this.dataSource.name} } from './mods/';
    export { defs };`;
    return file;
  }

  getModsIndex() {
    let conclusion = ``;

    // dataSource name means multiple dataSource
    if (this.dataSource.name) {
      conclusion = `
        export default {
          ${this.dataSource.mods
            .map((mod) => reviseModName(mod.name))
            .join(", \n")}
        };
      `;
    }

    return `
      ${this.dataSource.mods
        .map((mod) => {
          const modName = reviseModName(mod.name);
          return `import * as ${modName} from './${modName}';`;
        })
        .join("\n")}

      ${conclusion}
    `;
  }

  getInterfaceContent(inter: Interface) {
    const getBodyParamsCode = () => {
      const bodyParam = inter.parameters.find((param) => param.in === "body");
      return (bodyParam && bodyParam.dataType.generateCode()) || "";
    };

    const method = inter.method.toUpperCase();
    const bodyParams = getBodyParamsCode();

    const indeedParameters = inter.parameters.filter(
      (param) => param.in === "path" || param.in === "query"
    );
    const hasParameters = indeedParameters.length > 0;

    const requestBody = `data: ${bodyParams}${
      hasParameters ? ", params: Params" : ""
    }`;

    const surrounding = this.surrounding;
    // console.log(this.dataSource);
    const genGetParams = () => {
      return `interface Params {
        ${indeedParameters
          .map((param) => param.toPropertyCode(surrounding, true))
          .join("")}
      }
    `;
    };

    const dealObjectMap = (codes: string) => {
      return codes
        .replace(/defs.ObjectMap/g, "ObjectMap")
        .replace(/ObjectMap/g, "defs.ObjectMap");
    };

    return `
    /**
     * @desc ${inter.description}
     */

    import * as defs from '../../baseClass';
    import { defHttp } from 'hailuo-http';
    export ${genGetParams()}

    export function request(${
      !bodyParams ? `params: Params` : requestBody
    }): Promise<${dealObjectMap(inter.response.generateCode())}> {
      return defHttp.${method.toLowerCase()}({
        url: '${inter.path}',
        ${bodyParams ? "data," : ""}
        ${hasParameters ? "params," : ""}
      })
    }

    export function mock(${
      !bodyParams ? `params: Params` : requestBody
    }): Promise<${dealObjectMap(inter.response.generateCode())}> {
      return defHttp.${method.toLowerCase()}({
        url: '/mock${inter.path}',
        ${bodyParams ? "data," : ""}
        ${hasParameters ? "params," : ""}
      })
    }
   `;
  }
}