package.ts

import os from 'os';
import path from 'path';
import fs from 'fs-extra';
import Table from 'tty-table';
import { doDelete, getAllPackages, post, uploadFile } from './api';
import { getPlatform, getSelectedApp } from './app';
import type { Platform } from './types';
import {
  getAabInfo,
  getApkInfo,
  getAppInfo,
  getIpaInfo,
  question,
  saveToLocal,
} from './utils';
import { AabParser } from './utils/app-info-parser/aab';
import { depVersions } from './utils/dep-versions';
import { getCommitInfo } from './utils/git';
import { t } from './utils/i18n';

export async function listPackage(appId: string) {
  const allPkgs = (await getAllPackages(appId)) || [];

  const header = [
    { value: t('nativePackageId') },
    { value: t('nativeVersion') },
  ];
  const rows = [];
  for (const pkg of allPkgs) {
    const { version } = pkg;
    let versionInfo = '';
    if (version) {
      const versionObj = version as any;
      versionInfo = t('boundTo', {
        name: versionObj.name || version,
        id: versionObj.id || version,
      });
    }
    let output = pkg.name;
    if (pkg.status === 'paused') {
      output += t('pausedStatus');
    }
    if (pkg.status === 'expired') {
      output += t('expiredStatus');
    }
    output += versionInfo;
    rows.push([pkg.id, output]);
  }

  console.log(Table(header, rows).render());
  console.log(t('totalPackages', { count: allPkgs.length }));
  return allPkgs;
}

export async function choosePackage(appId: string) {
  const list = await listPackage(appId);

  while (true) {
    const id = await question(t('enterNativePackageId'));
    const app = list?.find((v) => v.id.toString() === id);
    if (app) {
      return app;
    }
  }
}

export const packageCommands = {
  uploadIpa: async ({
    args,
    options,
  }: {
    args: string[];
    options: Record<string, any>;
  }) => {
    const fn = args[0];
    if (!fn || !fn.endsWith('.ipa')) {
      throw new Error(t('usageUploadIpa'));
    }
    const ipaInfo = await getIpaInfo(fn);
    const { versionName: extractedVersionName, buildTime } = ipaInfo;
    const appIdInPkg = (ipaInfo as any).appId;
    const appKeyInPkg = (ipaInfo as any).appKey;
    const { appId, appKey } = await getSelectedApp('ios');

    if (appIdInPkg && appIdInPkg != appId) {
      throw new Error(t('appIdMismatchIpa', { appIdInPkg, appId }));
    }

    if (appKeyInPkg && appKeyInPkg !== appKey) {
      throw new Error(t('appKeyMismatchIpa', { appKeyInPkg, appKey }));
    }

    // Use custom version if provided, otherwise use extracted version
    const versionName = options.version || extractedVersionName;
    if (options.version) {
      console.log(t('usingCustomVersion', { version: versionName }));
    }

    const { hash } = await uploadFile(fn);

    const { id } = await post(`/app/${appId}/package/create`, {
      name: versionName,
      hash,
      buildTime,
      deps: depVersions,
      commit: await getCommitInfo(),
    });
    saveToLocal(fn, `${appId}/package/${id}.ipa`);
    console.log(t('ipaUploadSuccess', { id, version: versionName, buildTime }));
  },
  uploadApk: async ({
    args,
    options,
  }: {
    args: string[];
    options: Record<string, any>;
  }) => {
    const fn = args[0];
    if (!fn || !fn.endsWith('.apk')) {
      throw new Error(t('usageUploadApk'));
    }
    const apkInfo = await getApkInfo(fn);
    const { versionName: extractedVersionName, buildTime } = apkInfo;
    const appIdInPkg = (apkInfo as any).appId;
    const appKeyInPkg = (apkInfo as any).appKey;
    const { appId, appKey } = await getSelectedApp('android');

    if (appIdInPkg && appIdInPkg != appId) {
      throw new Error(t('appIdMismatchApk', { appIdInPkg, appId }));
    }

    if (appKeyInPkg && appKeyInPkg !== appKey) {
      throw new Error(t('appKeyMismatchApk', { appKeyInPkg, appKey }));
    }

    // Use custom version if provided, otherwise use extracted version
    const versionName = options.version || extractedVersionName;
    if (options.version) {
      console.log(t('usingCustomVersion', { version: versionName }));
    }

    const { hash } = await uploadFile(fn);

    const { id } = await post(`/app/${appId}/package/create`, {
      name: versionName,
      hash,
      buildTime,
      deps: depVersions,
      commit: await getCommitInfo(),
    });
    saveToLocal(fn, `${appId}/package/${id}.apk`);
    console.log(t('apkUploadSuccess', { id, version: versionName, buildTime }));
  },
  uploadAab: async ({
    args,
    options,
  }: {
    args: string[];
    options: Record<string, any>;
  }) => {
    const source = args[0];
    if (!source || !source.endsWith('.aab')) {
      throw new Error(t('usageUploadAab'));
    }

    const output = path.join(
      os.tmpdir(),
      `${path.basename(source, path.extname(source))}-${Date.now()}.apk`,
    );

    const includeAllSplits =
      options.includeAllSplits === true || options.includeAllSplits === 'true';
    const splits = options.splits
      ? String(options.splits)
          .split(',')
          .map((item) => item.trim())
          .filter(Boolean)
      : null;

    const parser = new AabParser(source);
    try {
      await parser.extractApk(output, {
        includeAllSplits,
        splits,
      });
      await packageCommands.uploadApk({
        args: [output],
        options,
      });
    } finally {
      if (await fs.pathExists(output)) {
        await fs.remove(output);
      }
    }
  },
  uploadApp: async ({
    args,
    options,
  }: {
    args: string[];
    options: Record<string, any>;
  }) => {
    const fn = args[0];
    if (!fn || !fn.endsWith('.app')) {
      throw new Error(t('usageUploadApp'));
    }
    const appInfo = await getAppInfo(fn);
    const { versionName: extractedVersionName, buildTime } = appInfo;
    const appIdInPkg = (appInfo as any).appId;
    const appKeyInPkg = (appInfo as any).appKey;
    const { appId, appKey } = await getSelectedApp('harmony');

    if (appIdInPkg && appIdInPkg != appId) {
      throw new Error(t('appIdMismatchApp', { appIdInPkg, appId }));
    }

    if (appKeyInPkg && appKeyInPkg !== appKey) {
      throw new Error(t('appKeyMismatchApp', { appKeyInPkg, appKey }));
    }

    // Use custom version if provided, otherwise use extracted version
    const versionName = options.version || extractedVersionName;
    if (options.version) {
      console.log(t('usingCustomVersion', { version: versionName }));
    }

    const { hash } = await uploadFile(fn);

    const { id } = await post(`/app/${appId}/package/create`, {
      name: versionName,
      hash,
      buildTime,
      deps: depVersions,
      commit: await getCommitInfo(),
    });
    saveToLocal(fn, `${appId}/package/${id}.app`);
    console.log(t('appUploadSuccess', { id, version: versionName, buildTime }));
  },
  parseApp: async ({ args }: { args: string[] }) => {
    const fn = args[0];
    if (!fn || !fn.endsWith('.app')) {
      throw new Error(t('usageParseApp'));
    }
    console.log(await getAppInfo(fn));
  },
  parseIpa: async ({ args }: { args: string[] }) => {
    const fn = args[0];
    if (!fn || !fn.endsWith('.ipa')) {
      throw new Error(t('usageParseIpa'));
    }
    console.log(await getIpaInfo(fn));
  },
  parseApk: async ({ args }: { args: string[] }) => {
    const fn = args[0];
    if (!fn || !fn.endsWith('.apk')) {
      throw new Error(t('usageParseApk'));
    }
    console.log(await getApkInfo(fn));
  },
  parseAab: async ({ args }: { args: string[] }) => {
    const fn = args[0];
    if (!fn || !fn.endsWith('.aab')) {
      throw new Error(t('usageParseAab'));
    }
    console.log(await getAabInfo(fn));
  },
  extractApk: async ({
    args,
    options,
  }: {
    args: string[];
    options: Record<string, any>;
  }) => {
    const source = args[0];
    if (!source || !source.endsWith('.aab')) {
      throw new Error(t('usageExtractApk'));
    }

    const output =
      options.output ||
      path.join(
        path.dirname(source),
        `${path.basename(source, path.extname(source))}.apk`,
      );

    const includeAllSplits =
      options.includeAllSplits === true || options.includeAllSplits === 'true';
    const splits = options.splits
      ? String(options.splits)
          .split(',')
          .map((item) => item.trim())
          .filter(Boolean)
      : null;

    const parser = new AabParser(source);
    await parser.extractApk(output, {
      includeAllSplits,
      splits,
    });

    console.log(t('apkExtracted', { output }));
  },
  packages: async ({ options }: { options: { platform: Platform } }) => {
    const platform = await getPlatform(options.platform);
    const { appId } = await getSelectedApp(platform);
    await listPackage(appId);
  },
  deletePackage: async ({
    args,
    options,
  }: {
    args: string[];
    options: {
      appId?: string;
      packageId?: string;
      packageVersion?: string;
      platform?: Platform;
    };
  }) => {
    let { appId, packageId, packageVersion } = options;

    if (!appId) {
      const platform = await getPlatform(options.platform);
      appId = (await getSelectedApp(platform)).appId as string;
    }

    // If no packageId provided as argument, let user choose from list
    if (!packageId) {
      const allPkgs = await getAllPackages(appId);
      if (!allPkgs) {
        throw new Error(t('noPackagesFound', { appId }));
      }
      const selectedPackage = allPkgs.find(
        (pkg) => pkg.name === packageVersion,
      );
      if (!selectedPackage) {
        throw new Error(t('packageNotFound', { packageVersion }));
      }
      packageId = selectedPackage.id;
    }

    // Confirm deletion
    // const confirmDelete = await question(
    //   t('confirmDeletePackage', { packageId }),
    // );

    // if (
    //   confirmDelete.toLowerCase() !== 'y' &&
    //   confirmDelete.toLowerCase() !== 'yes'
    // ) {
    //   console.log(t('cancelled'));
    //   return;
    // }

    try {
      await doDelete(`/app/${appId}/package/${packageId}`);
      console.log(t('deletePackageSuccess', { packageId }));
    } catch (error: any) {
      throw new Error(
        t('deletePackageError', { packageId, error: error.message }),
      );
    }
  },
};