import { readFileSync, writeFile } from "fs";
import * as ts from "typescript";

interface Method {
  name: string;
  method: "GET" | "POST";
  bodyType?: string;
  responseType?: string;
  urlParametersType?: string;

}
interface Endpoint {
  name: string;
  methods: Method[];
}

export function delint(sourceFile: ts.SourceFile) {
  let endpoints: Endpoint[] = [];
  delintNode(sourceFile);

  function delintNode(node: ts.Node) {

    if (ts.isInterfaceDeclaration(node) && node.name.text !== "Bla") {
      endpoints.push({
        name: node.name.text,
        methods: node.members.map((m)=> {
          if (ts.isPropertySignature(m)) {
            let type = m.type!;
            if (ts.isTypeLiteralNode(type)) {
              let params = type.members.reduce((o, m) => {
                if (ts.isPropertySignature(m)) {
                  o[m.name.getText()] = m.type.getText();
                  return o;
                }
            }, {} as any);
            return {
              name: m.name.getText(),
              method: params.method,
              bodyType: params.bodyType,
              responseType: params.responseType || "void",
              urlParametersType: params.urlParametersType,
            }
           }
          }
        })
      });
    } else {
      ts.forEachChild(node, delintNode);
    }
  }

  function fromEndpoint(endpoint: Endpoint) {
    function fromMethod(method: Method) {
      let parameters = ["urlParametersType", "bodyType"]
        .filter(p => !!method[p])
        .map(p => [p, method[p]] as [string, string])
        .map(p => [p[0].slice(0, p[0].length - 4), p[1]]);

      let parameterToString = p => `${p[0]}: ${p[1]}`;

      return `
  async ${method.name}(${parameters.map(parameterToString)}): Promise<${method.responseType}> {
    let home = await getHome();
    let response = await fetch(home.${method.name}, {
      method: ${method.method},
      headers: new Headers({
        'Content-Type': 'application/json'
      }),
      ${method.bodyType ? "body: JSON.stringify(body)," : ""}
    });

    return response.json();
  }`;
    }
    return `
export class ${endpoint.name} {
    ${endpoint.methods.map(fromMethod).join("\n")}
}
    `
  }

  let out = endpoints.map(fromEndpoint);
  writeFile("./yolo.ts", out, (err)=> {
    console.log({err});
  });
}

const fileNames = process.argv.slice(2);
fileNames.forEach(fileName => {
  // Parse a file
  let sourceFile = ts.createSourceFile(
    fileName,
    readFileSync(fileName).toString(),
    ts.ScriptTarget.ES2015,
    /*setParentNodes */ true
  );

  // delint it
  delint(sourceFile);
});