import * as fs from "fs";
import { generateTypes } from "./generator";
import { createProviderFactoryDirs } from "./read-abi-names";
const { dedent } = require("tslint/lib/utils");
const { resolve } = require("path");
const { readdir } = require("fs").promises;

async function* getFiles(dir) {
  const dirents = await readdir(dir, { withFileTypes: true });

  for (const dirent of dirents) {
    const res = resolve(dir, dirent.name);
    if (dirent.isDirectory()) {
      yield* getFiles(res);
    } else {
      console.log(res);
      yield res;
    }
  }
}

const ABI_ROOT_DIR = "src/abis";

const loadFile = async (filePath: string): Promise<any> => {
  return new Promise((resolve, reject) => {
    fs.readFile(filePath, "utf8", (error, data) => {
      if (error) {
        return;
      }
      resolve(JSON.parse(data));
    });
  });
};

const updateImport = async (contractName) => {
  try {
    const dirName = `${ABI_ROOT_DIR}/index.ts`;
    const fileData = fs.readFileSync(dirName);
    const fileAsStr = fileData.toString("utf8");

    // try {
    //   fs.unlinkSync(dirName);
    // } catch (err) {
    //   // console.error(err);
    // }

    fs.writeFileSync(
      dirName,
      dedent`${fileAsStr} \n export * from "./${contractName}.abi";`,
      { encoding: "utf8" }
    );
  } catch (err) {
    console.log(err);
  }
};

const template = ({ contractName, abi, bytecode }) => dedent`
import { JsonFragment } from "../abis.model";

const ${contractName}ABI: JsonFragment[] = ${JSON.stringify(abi)};
const ${contractName}ByteCode = ${JSON.stringify(bytecode)};

export { ${contractName}ABI, ${contractName}ByteCode };
`;

const updateTsFile = async (dirPath) => {
  try {
    const fileData = fs.readFileSync(dirPath);

    // try {
    //   fs.unlinkSync(fileData);
    // } catch (err) {
    //   // console.error(err);
    // }

    const fileAsStr = fileData.toString("utf8");
    fs.writeFileSync(
      dirPath,
      dedent`
      import { Overrides, Result, ContractTransactionReceipt } from "ethers";
      ${fileAsStr}`,
      { encoding: "utf8" }
    );
  } catch (err) {
    // console.log(err);
  }
};

export const buildAll = (allowedContracts: string[]) => {
  (async () => {
    try {
      const dirName = `${ABI_ROOT_DIR}/index.ts`;
      fs.writeFileSync(dirName, "");
    } catch (err) {
      // console.error(err);
    }
    for await (const f of getFiles("out")) {
      try {
        if (f?.includes(".json")) {
          let rawdata = await loadFile(f);
          let filename = f.split("/").pop();
          rawdata.contractName = filename.split(".")[0];
          if (allowedContracts.includes(rawdata?.contractName)) {
            const filePath = `${ABI_ROOT_DIR}/${rawdata?.contractName}`;
            if (!fs.existsSync(filePath)) {
              fs.writeFileSync(`${filePath}.abi.ts`, template(rawdata), {
                encoding: "utf8",
              });
              updateImport(rawdata?.contractName);
            }
            const providerPath = `src/ProviderFactory/${rawdata?.contractName}Provider/aut-contract-functions.ts`;

            await createProviderFactoryDirs(rawdata?.contractName);
            try {
              fs.unlinkSync(providerPath);
            } catch (err) {
              // console.error(err);
            }
            try {
              await generateTypes(
                providerPath,
                rawdata?.abi,
                rawdata?.contractName
              );
              await updateTsFile(providerPath);
            } catch (err) {
              console.error(err);
            }
          }
        }
      } catch (err) {
        console.error(err);
      }
    }
  })();
};