'use strict';

const core = require('@animespace/core');
const fs = require('fs-extra');
const path = require('pathe');
const node_child_process = require('node:child_process');
const openEditor = require('open-editor');
const breadc = require('breadc');
const color = require('@breadc/color');
const os = require('node:os');
const local = require('@animespace/local');
const bangumi = require('@animespace/bangumi');
const animegarden = require('@animespace/animegarden');

function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }

const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
const path__default = /*#__PURE__*/_interopDefaultCompat(path);
const openEditor__default = /*#__PURE__*/_interopDefaultCompat(openEditor);
const os__default = /*#__PURE__*/_interopDefaultCompat(os);

const version = "0.1.0-beta.20";
const description = "Create your own Anime Space";

async function loop(fn, duration) {
  let timestamp;
  core.onDeath(() => {
    clearTimeout(timestamp);
  });
  const time = parseDuration(duration);
  return new Promise(() => {
    const wrapper = async () => {
      await fn();
      timestamp = setTimeout(wrapper, time);
    };
    wrapper();
  });
}
function parseDuration(text) {
  const s = /^(\d+)s$/.exec(text);
  if (s) {
    return +s[1] * 1e3;
  }
  const m = /^(\d+)m$/.exec(text);
  if (m) {
    return +m[1] * 60 * 1e3;
  }
  const h = /^(\d+)h$/.exec(text);
  if (h) {
    return +h[1] * 60 * 60 * 1e3;
  }
  return 10 * 60 * 1e3;
}

const pluginLoader = {
  async animegarden(entry) {
    return animegarden.AnimeGarden(entry);
  },
  async bangumi(entry) {
    return bangumi.Bangumi(entry);
  },
  async local(entry) {
    return local.Local(entry);
  }
};
async function makeSystem(_root) {
  const root = _root ?? inferRoot();
  const space = await core.loadSpace(root, pluginLoader);
  const system = core.createSystem(space);
  return system;
}
function inferRoot() {
  try {
    const envRoot = process.env.ANIMESPACE_ROOT;
    if (envRoot) {
      return path__default.resolve(envRoot);
    }
  } finally {
    return path__default.resolve(os__default.homedir(), ".animespace");
  }
}

async function makeCliApp(system) {
  const app = breadc.breadc("anime", {
    version,
    description,
    plugins: [
      {
        onPreCommand(parsed) {
          if (parsed.options?.proxy) {
            core.proxy.enable = true;
          }
        }
      }
    ]
  }).option("--proxy", {
    description: "Enable HTTP/HTTPS proxy"
  });
  registerApp(system, app);
  for (const plugin of system.space.plugins) {
    await plugin.command?.(system, app);
  }
  return app;
}
function registerApp(system, app) {
  const isTTY = !!process?.stdout?.isTTY;
  app.command("space", "Display the space directory").option("--open", "Open space in your editor").action(async (options) => {
    const root = system.space.root;
    const cmds = options["--"];
    if (cmds.length > 0) {
      if (isTTY) {
        system.printSpace();
      }
      node_child_process.execSync(cmds.join(" "), { cwd: root.path, stdio: "inherit" });
    } else if (options.open) {
      try {
        openEditor__default([root.path]);
      } catch (error) {
        console.log(root);
      }
    } else {
      console.log(root);
    }
    return root;
  });
  app.command("run <command> [...args]", "Run command in the space directory").action(async (command, args) => {
    const pkgJson = await fs__default.readJSON(system.space.root.resolve("package.json").path).catch(() => void 0);
    const env = { ...process.env };
    env.PATH = [
      ...(process.env.PATH ?? "").split(path__default.delimiter),
      system.space.root.resolve("node_modules/.bin").path
    ].join(path__default.delimiter);
    if (pkgJson.scripts && command in pkgJson.scripts) {
      const cmd = pkgJson.scripts[command];
      if (isTTY) {
        system.printSpace();
      }
      node_child_process.execSync(cmd + " " + args.join(" "), {
        cwd: system.space.root.path,
        stdio: "inherit",
        env
      });
    } else {
      if (isTTY) {
        system.printSpace();
      }
      node_child_process.execSync(command + " " + args.join(" "), {
        cwd: system.space.root.path,
        stdio: "inherit",
        env
      });
    }
  });
  app.command("watch", "Watch anime system update").option("-d, --duration <time>", "Refresh time interval", {
    default: "10m"
  }).option("-i, --introspect", "Introspect library before refreshing").option("-f, --force", "Prefer not using any cache").action(async (options) => {
    let sys = system;
    if (options.introspect) {
      await sys.introspect();
    }
    const delta = [];
    const refresh = async () => {
      const cancel = registerDeath(sys);
      try {
        sys.printSpace();
        const animes = await sys.refresh({
          force: options.force,
          logDelta: false
        });
        delta.push(...animes.flatMap((a) => a.delta));
        if (delta.length > 0) {
          sys.logger.log("");
          sys.logger.log(
            `${color.dim("There are")} ${color.lightCyan(delta.length + " changes")} ${color.dim(
              "applied to the space"
            )}`
          );
          core.printDelta(sys.logger, delta);
        }
      } catch (error) {
        sys.logger.error(error);
      } finally {
        await writeBack(sys);
        sys = await makeSystem();
        sys.logger.log("");
        cancel();
      }
    };
    await loop(refresh, options.duration);
  });
  app.command("refresh", "Refresh the local anime system").option("--filter <keyword>", "Filter animes to be refreshed").option("--status <status>", {
    description: "Filter onair / finish animes",
    default: "onair",
    cast: (v) => v === "finish" ? "finish" : "onair"
  }).option("-i, --introspect", "Introspect library before refreshing").option("-f, --force", "Prefer not using any cache").action(async (options) => {
    registerDeath(system);
    system.printSpace();
    try {
      const filter = options.filter ? { keyword: options.filter, status: options.status } : options.status === "finish" ? { keyword: "", status: options.status } : void 0;
      if (options.introspect) {
        await system.introspect({
          filter
        });
      }
      const animes = await system.refresh({
        filter,
        force: options.force
      });
      return animes;
    } catch (error) {
      throw error;
    } finally {
      await writeBack(system);
    }
  });
  app.command("introspect", "Introspect the local anime system").option("--filter <keyword>", "Filter animes to be refreshed").action(async (options) => {
    registerDeath(system);
    system.printSpace();
    try {
      const animes = await system.introspect({ filter: options.filter });
      return animes;
    } catch (error) {
      throw error;
    } finally {
      await writeBack(system);
    }
  });
  function registerDeath(system2) {
    return core.onDeath(async (signal, context) => {
      system2.logger.log(color.lightRed("Process is being killed"));
      await writeBack(system2);
      context.terminate = "exit";
    });
  }
  async function writeBack(system2) {
    if (system2.isChanged()) {
      system2.logger.log(color.lightBlue("Writing back anime libraries"));
      system2.printDelta();
      await system2.writeBack();
      system2.logger.log(color.lightGreen("Anime libraries have been written back"));
    }
  }
}

exports.Anime = core.Anime;
exports.inferRoot = inferRoot;
exports.makeCliApp = makeCliApp;
exports.makeSystem = makeSystem;