versions.ts

import { doDelete, get, getAllPackages, post, put, uploadFile } from './api';
import { question, saveToLocal } from './utils';
import { t } from './utils/i18n';

import chalk from 'chalk';
import { satisfies } from 'compare-versions';
import Table from 'tty-table';
import { getPlatform, getSelectedApp } from './app';
import { choosePackage } from './package';
import type { Package, Platform, Version } from './types';
import { depVersions } from './utils/dep-versions';
import { getCommitInfo } from './utils/git';

interface VersionCommandOptions {
  appId?: string;
  name?: string;
  description?: string;
  metaInfo?: string;
  platform?: Platform;
  versionId?: string;
  packageId?: string;
  packageVersion?: string;
  minPackageVersion?: string;
  maxPackageVersion?: string;
  packageVersionRange?: string;
  rollout?: string;
  dryRun?: boolean;
  versionDeps?: Record<string, string>;
}

type Deps = Record<string, string>;
type DepChangeType = 'added' | 'removed' | 'changed';

interface DepChange {
  dependency: string;
  oldVersion: string;
  newVersion: string;
  type: DepChangeType;
}

interface DepsChangeSummary {
  added: number;
  removed: number;
  changed: number;
}

function normalizeDeps(input: unknown): Deps | undefined {
  if (!input) {
    return undefined;
  }

  let raw: unknown = input;
  if (typeof input === 'string') {
    try {
      raw = JSON.parse(input);
    } catch (_e) {
      return undefined;
    }
  }

  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
    return undefined;
  }

  const deps: Deps = {};
  for (const [name, version] of Object.entries(
    raw as Record<string, unknown>,
  )) {
    if (typeof version === 'string' && version) {
      deps[name] = version;
    }
  }

  return Object.keys(deps).length > 0 ? deps : undefined;
}

function getDepsChanges(oldDeps?: Deps, newDeps?: Deps): DepChange[] {
  if (!oldDeps || !newDeps) {
    return [];
  }

  const rows: DepChange[] = [];
  const keys = Object.keys({ ...oldDeps, ...newDeps }).sort((a, b) =>
    a.localeCompare(b),
  );

  for (const key of keys) {
    const oldVersion = oldDeps[key];
    const newVersion = newDeps[key];

    if (oldVersion === undefined && newVersion !== undefined) {
      rows.push({
        dependency: key,
        oldVersion: '-',
        newVersion,
        type: 'added',
      });
      continue;
    }

    if (oldVersion !== undefined && newVersion === undefined) {
      rows.push({
        dependency: key,
        oldVersion,
        newVersion: '-',
        type: 'removed',
      });
      continue;
    }

    if (
      oldVersion !== undefined &&
      newVersion !== undefined &&
      oldVersion !== newVersion
    ) {
      rows.push({
        dependency: key,
        oldVersion,
        newVersion,
        type: 'changed',
      });
    }
  }

  return rows;
}

function getDepsChangeSummary(changes: DepChange[]): DepsChangeSummary {
  return changes.reduce(
    (acc, item) => {
      if (item.type === 'added') {
        acc.added += 1;
      } else if (item.type === 'removed') {
        acc.removed += 1;
      } else {
        acc.changed += 1;
      }
      return acc;
    },
    { added: 0, removed: 0, changed: 0 },
  );
}

function renderVersionChange(change: DepChange) {
  const arrow = chalk.gray(` ${t('depsChangeArrow')} `);

  if (change.type === 'added') {
    return `${chalk.red(t('depsChangeAddedLabel'))} | ${chalk.gray(
      change.oldVersion,
    )}${arrow}${chalk.red(change.newVersion)}`;
  }

  if (change.type === 'removed') {
    return `${chalk.green(t('depsChangeRemovedLabel'))} | ${chalk.green(
      change.oldVersion,
    )}${arrow}${chalk.gray(change.newVersion)}`;
  }

  return `${chalk.yellow(t('depsChangeChangedLabel'))} | ${chalk.yellow(
    change.oldVersion,
  )}${arrow}${chalk.yellow(change.newVersion)}`;
}

function printDepsChangesForPackage({
  pkg,
  versionDeps,
}: {
  pkg: Package;
  versionDeps: Deps;
}) {
  const pkgDeps = normalizeDeps(pkg.deps);
  if (!pkgDeps) {
    return false;
  }

  const changes = getDepsChanges(pkgDeps, versionDeps);
  if (changes.length === 0) {
    return false;
  }

  const summary = getDepsChangeSummary(changes);
  const summaryText = t('depsChangeSummary', {
    added: chalk.red(String(summary.added)),
    removed: chalk.green(String(summary.removed)),
    changed: chalk.yellow(String(summary.changed)),
  });
  const header = [
    { value: t('depsChangeDependencyHeader') },
    { value: t('depsChangeVersionHeader') },
  ];
  const rows = changes.map((change) => [
    change.dependency,
    renderVersionChange(change),
  ]);

  console.log('');
  console.log(
    chalk.yellow(
      t('depsChangeTargetPackage', {
        packageName: pkg.name,
        packageId: pkg.id,
      }),
    ),
  );
  console.log(summaryText);
  console.log(Table(header, rows).render());
  console.log(chalk.yellow(t('depsChangeRiskWarning')));
  return true;
}

async function findVersionDeps(appId: string, versionId: string) {
  const targetId = String(versionId);
  const limit = 100;
  let offset = 0;

  while (true) {
    const { data, count } = await get(
      `/app/${appId}/version/list?offset=${offset}&limit=${limit}`,
    );
    const versions: Version[] = Array.isArray(data) ? data : [];
    const version = versions.find((item) => String(item.id) === targetId);

    if (version) {
      return normalizeDeps(version.deps);
    }

    offset += versions.length;
    if (versions.length === 0 || offset >= Number(count || 0)) {
      break;
    }
  }

  return undefined;
}

async function printDepsChangesForPublish({
  appId,
  versionId,
  pkgs,
  providedVersionDeps,
}: {
  appId: string;
  versionId?: string;
  pkgs: Package[];
  providedVersionDeps?: Deps;
}) {
  if (!versionId || pkgs.length === 0) {
    return;
  }

  let versionDeps = normalizeDeps(providedVersionDeps);
  if (!versionDeps) {
    try {
      versionDeps = await findVersionDeps(appId, versionId);
    } catch (error: any) {
      console.warn(
        chalk.yellow(
          t('depsChangeFetchFailed', {
            error: error?.message || String(error),
          }),
        ),
      );
      return;
    }
  }

  if (!versionDeps) {
    return;
  }

  let hasChanges = false;
  for (const pkg of pkgs) {
    const printed = printDepsChangesForPackage({ pkg, versionDeps });
    hasChanges = hasChanges || printed;
  }

  if (hasChanges) {
    console.log(chalk.yellow(t('depsChangeNonBlockingHint')));
  }
}

async function showVersion(appId: string, offset: number) {
  const { data, count } = await get(`/app/${appId}/version/list`);
  console.log(t('offset', { offset }));
  for (const version of data) {
    const pkgCount = version.packages?.length || 0;
    let packageInfo = '';
    if (pkgCount === 0) {
      packageInfo = 'no package';
    } else {
      packageInfo = version.packages
        ?.slice(0, 3)
        .map((pkg: Package) => pkg.name)
        .join(', ');
      if (pkgCount > 3) {
        packageInfo += `...and ${pkgCount - 3} more`;
      } else {
        packageInfo = `[${packageInfo}]`;
      }
    }
    console.log(
      `${version.id}) ${version.hash.slice(0, 8)} ${
        version.name
      } ${packageInfo}`,
    );
  }
  return data;
}

async function listVersions(appId: string) {
  let offset = 0;
  while (true) {
    await showVersion(appId, offset);
    const cmd = await question('page Up/page Down/Begin/Quit(U/D/B/Q)');
    switch (cmd.toLowerCase()) {
      case 'u':
        offset = Math.max(0, offset - 10);
        break;
      case 'd':
        offset += 10;
        break;
      case 'b':
        offset = 0;
        break;
      case 'q':
        return;
    }
  }
}

async function chooseVersion(appId: string) {
  let offset = 0;
  while (true) {
    const data = await showVersion(appId, offset);
    const cmd = await question(
      'Enter versionId or page Up/page Down/Begin(U/D/B)',
    );
    switch (cmd.toUpperCase()) {
      case 'U':
        offset = Math.max(0, offset - 10);
        break;
      case 'D':
        offset += 10;
        break;
      case 'B':
        offset = 0;
        break;
      default: {
        const versionId = Number.parseInt(cmd, 10);
        const v = data.find(
          (version: Version) => version.id === String(versionId),
        );
        if (v) {
          return v;
        }
      }
    }
  }
}

export const bindVersionToPackages = async ({
  appId,
  versionId,
  pkgs,
  rollout,
  dryRun,
}: {
  appId: string;
  versionId: string;
  pkgs: Package[];
  rollout?: number;
  dryRun?: boolean;
}) => {
  if (dryRun) {
    console.log(chalk.yellow(t('dryRun')));
  }
  if (rollout !== undefined) {
    console.log(
      `${t('rolloutConfigSet', {
        versions: pkgs.map((pkg: Package) => pkg.name).join(', '),
        rollout: rollout,
      })}`,
    );
  }
  for (const pkg of pkgs) {
    if (!dryRun) {
      await post(`/app/${appId}/binding`, {
        versionId,
        rollout,
        packageId: pkg.id,
      });
    }
    console.log(
      `${t('versionBind', {
        version: versionId,
        nativeVersion: pkg.name,
        id: pkg.id,
      })}`,
    );
  }
  console.log(t('operationComplete', { count: pkgs.length }));
};

export const versionCommands = {
  publish: async function ({
    args,
    options,
  }: {
    args: string[];
    options: VersionCommandOptions;
  }) {
    const fn = args[0];
    const { name, description, metaInfo } = options;

    if (!fn || !fn.endsWith('.ppk')) {
      throw new Error(t('publishUsage'));
    }

    const platform = await getPlatform(options.platform);
    const { appId } = await getSelectedApp(platform);

    const { hash } = await uploadFile(fn);

    const versionName =
      name || (await question(t('versionNameQuestion'))) || t('unnamed');
    const { id } = await post(`/app/${appId}/version/create`, {
      name: versionName,
      hash,
      description:
        description || (await question(t('versionDescriptionQuestion'))),
      metaInfo: metaInfo || (await question(t('versionMetaInfoQuestion'))),
      deps: depVersions,
      commit: await getCommitInfo(),
    });
    // TODO local diff
    saveToLocal(fn, `${appId}/ppk/${id}.ppk`);
    console.log(t('packageUploadSuccess', { id }));

    const {
      packageId,
      packageVersion,
      packageVersionRange,
      minPackageVersion,
      maxPackageVersion,
      rollout,
      dryRun,
    } = options;

    if (
      packageId ||
      packageVersion ||
      packageVersionRange ||
      minPackageVersion ||
      maxPackageVersion
    ) {
      await this.update({
        options: {
          versionId: id,
          platform,
          packageId,
          packageVersion,
          packageVersionRange,
          minPackageVersion,
          maxPackageVersion,
          rollout,
          dryRun,
          versionDeps: depVersions,
        },
      });
    } else {
      const q = await question(t('updateNativePackageQuestion'));
      if (q.toLowerCase() === 'y') {
        await this.update({
          options: { versionId: id, platform, versionDeps: depVersions },
        });
      }
    }
    return versionName;
  },
  versions: async ({ options }: { options: VersionCommandOptions }) => {
    const platform = await getPlatform(options.platform);
    const { appId } = await getSelectedApp(platform);
    await listVersions(String(appId));
  },
  update: async ({ options }: { options: VersionCommandOptions }) => {
    const platform = await getPlatform(options.platform);
    const appId = options.appId || (await getSelectedApp(platform)).appId;
    let versionId = options.versionId || (await chooseVersion(String(appId))).id;
    if (versionId === 'null') {
      versionId = undefined;
    }

    let pkgId = options.packageId;
    let pkgVersion = options.packageVersion;
    let minPkgVersion = options.minPackageVersion;
    let maxPkgVersion = options.maxPackageVersion;
    let packageVersionRange = options.packageVersionRange;
    let rollout: number | undefined = undefined;

    if (options.rollout !== undefined) {
      try {
        rollout = Number.parseInt(options.rollout);
      } catch (e) {
        throw new Error(t('rolloutRangeError'));
      }
      if (rollout < 1 || rollout > 100) {
        throw new Error(t('rolloutRangeError'));
      }
    }

    const allPkgs = await getAllPackages(String(appId));

    if (!allPkgs) {
      throw new Error(t('noPackagesFound', { appId }));
    }

    let pkgsToBind: Package[] = [];

    if (minPkgVersion) {
      minPkgVersion = String(minPkgVersion).trim();
      pkgsToBind = allPkgs.filter((pkg: Package) =>
        satisfies(pkg.name, `>=${minPkgVersion}`),
      );
      if (pkgsToBind.length === 0) {
        throw new Error(
          t('nativeVersionNotFoundGte', { version: minPkgVersion }),
        );
      }
    } else if (maxPkgVersion) {
      maxPkgVersion = String(maxPkgVersion).trim();
      pkgsToBind = allPkgs.filter((pkg: Package) =>
        satisfies(pkg.name, `<=${maxPkgVersion}`),
      );
      if (pkgsToBind.length === 0) {
        throw new Error(
          t('nativeVersionNotFoundLte', { version: maxPkgVersion }),
        );
      }
    } else if (pkgVersion) {
      pkgVersion = pkgVersion.trim();
      const pkg = allPkgs.find((pkg: Package) => pkg.name === pkgVersion);
      if (pkg) {
        pkgsToBind = [pkg];
      } else {
        throw new Error(
          t('nativeVersionNotFoundMatch', { version: pkgVersion }),
        );
      }
    } else if (packageVersionRange) {
      packageVersionRange = packageVersionRange.trim();
      pkgsToBind = allPkgs.filter((pkg: Package) =>
        satisfies(pkg.name, packageVersionRange!),
      );
      if (pkgsToBind.length === 0) {
        throw new Error(
          t('nativeVersionNotFoundMatch', { version: packageVersionRange }),
        );
      }
    } else {
      if (!pkgId) {
        pkgId = (await choosePackage(String(appId))).id;
      }

      if (!pkgId) {
        throw new Error(t('packageIdRequired'));
      }
      const pkg = allPkgs.find(
        (pkg: Package) => String(pkg.id) === String(pkgId),
      );
      if (pkg) {
        pkgsToBind = [pkg];
      } else {
        throw new Error(t('nativePackageIdNotFound', { id: pkgId }));
      }
    }

    await printDepsChangesForPublish({
      appId: String(appId),
      versionId: String(versionId),
      pkgs: pkgsToBind,
      providedVersionDeps: options.versionDeps,
    });

    await bindVersionToPackages({
      appId: String(appId),
      versionId: String(versionId),
      pkgs: pkgsToBind,
      rollout,
      dryRun: options.dryRun,
    });
  },
  updateVersionInfo: async ({
    options,
  }: {
    options: VersionCommandOptions;
  }) => {
    const platform = await getPlatform(options.platform);
    const { appId } = await getSelectedApp(platform);
    const versionId = options.versionId || (await chooseVersion(String(appId))).id;

    const updateParams: Record<string, string> = {};
    if (options.name) updateParams.name = options.name;
    if (options.description) updateParams.description = options.description;
    if (options.metaInfo) updateParams.metaInfo = options.metaInfo;

    await put(`/app/${String(appId)}/version/${versionId}`, updateParams);
    console.log(t('operationSuccess'));
  },
  deleteVersion: async ({
    options,
  }: {
    options: VersionCommandOptions;
  }) => {
    let appId = options.appId;
    if (!appId) {
      const platform = await getPlatform(options.platform);
      appId = (await getSelectedApp(platform)).appId;
    }

    let versionId = options.versionId;
    if (!versionId) {
      versionId = (await chooseVersion(String(appId))).id;
    }

    try {
      await doDelete(`/app/${String(appId)}/version/${versionId}`);
      console.log(t('deleteVersionSuccess', { versionId }));
    } catch (error: any) {
      throw new Error(
        t('deleteVersionError', { versionId, error: error.message }),
      );
    }
  },
};