import type * as interfaces from '@serve.zone/interfaces';
import type {
  IAppStoreResolverOptions,
  IParsedDockerImageReference,
  IResolvedAppStoreApp,
  TAppStoreApp,
  TAppStoreDockerImageSource,
  TAppStoreIndex,
  TAppStoreRepoManifestSource,
  TAppStoreResolvedSource,
  TAppStoreVersionConfig,
  TServezoneAppStoreManifest,
} from './types.js';

export class AppStoreResolver {
  public readonly baseUrl: string;
  private readonly fetchRef: typeof fetch;
  private readonly resolveDockerDigests: boolean;
  private readonly now: () => Date;
  private appStoreCache: TAppStoreIndex | null = null;
  private sourceAppCache = new Map<string, IResolvedAppStoreApp>();

  constructor(optionsArg: IAppStoreResolverOptions = {}) {
    this.baseUrl = optionsArg.baseUrl || 'https://code.foss.global/serve.zone/appstore/raw/branch/main';
    this.fetchRef = optionsArg.fetch || fetch;
    this.resolveDockerDigests = optionsArg.resolveDockerDigests ?? true;
    this.now = optionsArg.now || (() => new Date());
  }

  public async getAppStoreIndex(): Promise<TAppStoreIndex> {
    if (this.appStoreCache) {
      return this.appStoreCache;
    }
    const appStore = await this.fetchAppStoreIndex();
    this.appStoreCache = await this.resolveAppStore(appStore);
    return this.appStoreCache;
  }

  public async getApps(): Promise<TAppStoreApp[]> {
    return (await this.getAppStoreIndex()).apps;
  }

  public async getAppMeta(appIdArg: string): Promise<interfaces.appstore.IAppStoreAppMeta> {
    const app = await this.getAppStoreApp(appIdArg);
    if (app?.source?.type === 'repoManifest') {
      return (await this.resolveRepoManifestSource(app.source, app)).appMeta;
    }
    if (app?.source?.type === 'dockerImage') {
      return this.createAppMetaFromAppStoreApp(app);
    }
    return await this.fetchJson(`apps/${appIdArg}/app.json`) as interfaces.appstore.IAppStoreAppMeta;
  }

  public async getAppVersionConfig(
    appIdArg: string,
    versionArg: string,
  ): Promise<TAppStoreVersionConfig> {
    const app = await this.getAppStoreApp(appIdArg);
    if (app?.source?.type === 'repoManifest') {
      const resolvedApp = await this.resolveRepoManifestSource(app.source, app);
      const config = resolvedApp.configsByVersion.get(versionArg);
      if (!config) {
        throw new Error(`Version '${versionArg}' is not defined by the linked appstore manifest`);
      }
      this.validateAppStoreVersionConfig(config, `${appIdArg}@${versionArg}`);
      return config;
    }

    if (app?.source?.type === 'dockerImage' && app.runtime) {
      const config: TAppStoreVersionConfig = { ...app.runtime };
      await this.applyDockerImageSourceToConfig(app.source, config, versionArg);
      this.validateAppStoreVersionConfig(config, `${appIdArg}@${versionArg}`);
      return config;
    }

    let config: TAppStoreVersionConfig;
    try {
      config = await this.fetchJson(`apps/${appIdArg}/versions/${versionArg}/config.json`) as TAppStoreVersionConfig;
    } catch (error) {
      if (app?.source?.type !== 'dockerImage') {
        throw error;
      }
      const appMeta = await this.fetchJson(`apps/${appIdArg}/app.json`) as interfaces.appstore.IAppStoreAppMeta;
      config = await this.fetchJson(`apps/${appIdArg}/versions/${appMeta.latestVersion}/config.json`) as TAppStoreVersionConfig;
    }

    if (app?.source?.type === 'dockerImage') {
      await this.applyDockerImageSourceToConfig(app.source, config, versionArg);
    }
    this.validateAppStoreVersionConfig(config, `${appIdArg}@${versionArg}`);
    return config;
  }

  public async resolveAppStore(appStoreArg: unknown): Promise<TAppStoreIndex> {
    const appStore = parseAppStoreIndex(appStoreArg);
    this.sourceAppCache.clear();
    const apps: TAppStoreApp[] = [];

    for (const app of appStore.apps) {
      apps.push(await this.resolveAppStoreApp(app));
    }

    return {
      ...appStore,
      apps,
      resolvedAt: this.now().toISOString(),
    };
  }

  public async resolveRepoManifestSource(
    sourceArg: TAppStoreRepoManifestSource,
    appArg?: TAppStoreApp,
  ): Promise<IResolvedAppStoreApp> {
    const cacheKey = `${sourceArg.url}#${sourceArg.ref || ''}`;
    const cachedApp = this.sourceAppCache.get(cacheKey);
    if (cachedApp) {
      return cachedApp;
    }

    const manifestText = await this.fetchTextFromUrl(sourceArg.url);
    const manifestHash = await createSha256Hex(manifestText);
    const manifest = parseServezoneAppStoreManifest(JSON.parse(manifestText));
    const resolvedApp = await this.resolveServezoneAppStoreManifest(manifest, {
      type: 'repoManifest',
      url: sourceArg.url,
      ref: sourceArg.ref,
      manifestHash,
      resolvedAt: this.now().toISOString(),
    });

    if (appArg) {
      resolvedApp.appStoreApp = {
        ...resolvedApp.appStoreApp,
        ...withoutUndefined(appArg),
        latestVersion: resolvedApp.appStoreApp.latestVersion,
        versions: resolvedApp.appStoreApp.versions,
        source: appArg.source,
        tags: appArg.tags || resolvedApp.appStoreApp.tags,
        resolvedSource: resolvedApp.appStoreApp.resolvedSource,
      };
      resolvedApp.appMeta = {
        ...resolvedApp.appMeta,
        id: resolvedApp.appStoreApp.id,
        name: resolvedApp.appStoreApp.name,
        description: resolvedApp.appStoreApp.description,
        category: resolvedApp.appStoreApp.category,
        iconName: resolvedApp.appStoreApp.iconName,
        latestVersion: resolvedApp.appStoreApp.latestVersion,
        versions: resolvedApp.appStoreApp.versions || resolvedApp.appMeta.versions,
        tags: resolvedApp.appStoreApp.tags,
        source: appArg.source,
        resolvedSource: resolvedApp.appStoreApp.resolvedSource,
      };
    }

    this.sourceAppCache.set(cacheKey, resolvedApp);
    return resolvedApp;
  }

  public async resolveDockerImageSource(
    sourceArg: TAppStoreDockerImageSource,
  ): Promise<TAppStoreResolvedSource> {
    let imageDigest: string | undefined;
    if (sourceArg.tracking === 'digest' && this.resolveDockerDigests) {
      imageDigest = await this.resolveDockerImageDigest(sourceArg.image) || undefined;
    }

    return {
      type: 'dockerImage',
      image: sourceArg.image,
      imageDigest,
      resolvedAt: this.now().toISOString(),
    };
  }

  public async resolveDockerImageDigest(imageArg: string): Promise<string | null> {
    const parsedImage = parseDockerImageReference(imageArg);
    if (parsedImage.digest) {
      return parsedImage.digest;
    }
    return await this.fetchDockerManifestDigest(parsedImage);
  }

  public validateAppStoreVersionConfig(
    configArg: TAppStoreVersionConfig,
    labelArg = 'appstore config',
  ): void {
    if (!configArg || typeof configArg !== 'object') {
      throw new Error(`Invalid ${labelArg}: config must be an object`);
    }
    if (!configArg.image || typeof configArg.image !== 'string') {
      throw new Error(`Invalid ${labelArg}: image is required`);
    }
    this.assertValidPort(configArg.port, `${labelArg} port`);

    for (const envVar of configArg.envVars || []) {
      if (!envVar.key || !/^[A-Z_][A-Z0-9_]*$/.test(envVar.key)) {
        throw new Error(`Invalid ${labelArg}: env var key '${envVar.key}' is not valid`);
      }
      if (envVar.value !== undefined && typeof envVar.value !== 'string') {
        throw new Error(`Invalid ${labelArg}: env var '${envVar.key}' value must be a string`);
      }
    }

    this.normalizeVolumes(configArg.volumes);
    this.validatePublishedPorts(configArg.publishedPorts || [], labelArg);
  }

  public normalizeVolumes(
    volumesArg: TAppStoreVersionConfig['volumes'] = [],
  ): interfaces.appstore.IAppStoreVolume[] {
    return volumesArg.map((volumeArg): interfaces.appstore.IAppStoreVolume => {
      if (typeof volumeArg === 'string') {
        return { mountPath: volumeArg };
      }
      return volumeArg;
    }).map((volumeArg, indexArg) => {
      this.validateVolume(volumeArg, `volume ${indexArg + 1}`);
      return volumeArg;
    });
  }

  private async fetchAppStoreIndex(): Promise<TAppStoreIndex> {
    try {
      return await this.fetchJson('appstore.resolved.json') as TAppStoreIndex;
    } catch {
      return await this.fetchJson('appstore.json') as TAppStoreIndex;
    }
  }

  private async resolveAppStoreApp(appArg: TAppStoreApp): Promise<TAppStoreApp> {
    if (appArg.source?.type === 'repoManifest') {
      const resolvedApp = await this.resolveRepoManifestSource(appArg.source, appArg);
      return {
        ...resolvedApp.appStoreApp,
        ...withoutUndefined(appArg),
        latestVersion: resolvedApp.appStoreApp.latestVersion,
        versions: resolvedApp.appStoreApp.versions,
        source: appArg.source,
        tags: appArg.tags || resolvedApp.appStoreApp.tags,
        resolvedSource: resolvedApp.appStoreApp.resolvedSource,
      };
    }

    if (appArg.source?.type === 'dockerImage') {
      const config = appArg.runtime ? { ...appArg.runtime } : undefined;
      const resolvedSource = config
        ? (await this.applyDockerImageSourceToConfig(appArg.source, config, appArg.latestVersion)).resolvedSource
        : await this.resolveDockerImageSource(appArg.source);
      const latestVersion = createAppStoreVersionForDockerSource(
        appArg.source,
        appArg.latestVersion,
        resolvedSource?.imageDigest,
      );
      return {
        ...appArg,
        runtime: config,
        latestVersion,
        versions: uniqueStrings([...(appArg.versions || []), latestVersion]),
        upgradeStrategy: appArg.source.tracking === 'digest' ? 'dockerDigest' : appArg.upgradeStrategy,
        resolvedSource,
      };
    }

    return appArg;
  }

  private async resolveServezoneAppStoreManifest(
    manifestArg: TServezoneAppStoreManifest,
    resolvedSourceArg: TAppStoreResolvedSource,
  ): Promise<IResolvedAppStoreApp> {
    const configsByVersion = new Map<string, TAppStoreVersionConfig>();
    const versions: string[] = [];
    const sourceVersionToResolvedVersion = new Map<string, string>();

    for (const versionArg of manifestArg.versions || []) {
      const sourceVersion = versionArg.version;
      const { version: _version, ...versionConfig } = versionArg;
      const config: TAppStoreVersionConfig = {
        ...versionConfig,
        source: versionConfig.source || manifestArg.source,
        resolvedSource: resolvedSourceArg,
      };
      await this.resolveConfigSource(config, sourceVersion);
      const resolvedVersion = config.appStoreVersion || sourceVersion;
      config.appStoreVersion = resolvedVersion;
      this.validateAppStoreVersionConfig(config, `${manifestArg.app.id}@${resolvedVersion}`);
      configsByVersion.set(resolvedVersion, config);
      configsByVersion.set(sourceVersion, config);
      versions.push(resolvedVersion);
      sourceVersionToResolvedVersion.set(sourceVersion, resolvedVersion);
    }

    if (manifestArg.runtime) {
      const sourceVersion = manifestArg.latestVersion || manifestArg.channel || 'latest';
      const config: TAppStoreVersionConfig = {
        ...manifestArg.runtime,
        source: manifestArg.runtime.source || manifestArg.source,
        resolvedSource: resolvedSourceArg,
      };
      await this.resolveConfigSource(config, sourceVersion);
      const resolvedVersion = config.appStoreVersion || sourceVersion;
      config.appStoreVersion = resolvedVersion;
      this.validateAppStoreVersionConfig(config, `${manifestArg.app.id}@${resolvedVersion}`);
      configsByVersion.set(resolvedVersion, config);
      configsByVersion.set(sourceVersion, config);
      versions.push(resolvedVersion);
      sourceVersionToResolvedVersion.set(sourceVersion, resolvedVersion);
    }

    if (configsByVersion.size === 0) {
      throw new Error('Appstore manifest must define at least one runtime config or version');
    }

    const selectedChannel = manifestArg.policy?.defaultChannel || manifestArg.channel || 'stable';
    const channelVersion = manifestArg.channels?.[selectedChannel];
    const declaredLatestVersion = manifestArg.latestVersion || channelVersion || versions[versions.length - 1];
    const latestVersion = sourceVersionToResolvedVersion.get(declaredLatestVersion) || declaredLatestVersion;
    const uniqueVersions = uniqueStrings(versions);

    const appStoreApp: TAppStoreApp = {
      id: manifestArg.app.id,
      name: manifestArg.app.name,
      description: manifestArg.app.description,
      category: manifestArg.app.category,
      iconName: manifestArg.app.iconName,
      iconUrl: manifestArg.app.iconUrl,
      latestVersion,
      versions: uniqueVersions,
      tags: manifestArg.app.tags,
      channel: selectedChannel,
      source: manifestArg.source,
      upgradeStrategy: getUpgradeStrategyForConfig(configsByVersion.get(latestVersion)),
      resolvedSource: resolvedSourceArg,
    };

    const appMeta: interfaces.appstore.IAppStoreAppMeta = {
      id: manifestArg.app.id,
      name: manifestArg.app.name,
      description: manifestArg.app.description,
      category: manifestArg.app.category,
      iconName: manifestArg.app.iconName,
      latestVersion,
      versions: uniqueVersions,
      maintainer: manifestArg.app.maintainer,
      links: manifestArg.app.links,
      tags: manifestArg.app.tags,
      source: manifestArg.source,
      resolvedSource: resolvedSourceArg,
    };

    return { appStoreApp, appMeta, configsByVersion };
  }

  private async resolveConfigSource(configArg: TAppStoreVersionConfig, versionArg: string): Promise<void> {
    if (configArg.source?.type === 'dockerImage') {
      await this.applyDockerImageSourceToConfig(configArg.source, configArg, versionArg);
    }
  }

  private async applyDockerImageSourceToConfig(
    sourceArg: TAppStoreDockerImageSource,
    configArg: TAppStoreVersionConfig,
    versionArg: string,
  ): Promise<TAppStoreVersionConfig> {
    configArg.image = sourceArg.image;
    configArg.source = sourceArg;

    const resolvedSource = await this.resolveDockerImageSource(sourceArg);
    configArg.resolvedSource = resolvedSource;
    configArg.resolvedImageDigest = resolvedSource.imageDigest;
    configArg.upgradeStrategy = sourceArg.tracking === 'digest' ? 'dockerDigest' : configArg.upgradeStrategy;
    configArg.appStoreVersion = createAppStoreVersionForDockerSource(
      sourceArg,
      versionArg,
      resolvedSource.imageDigest,
    );

    return configArg;
  }

  private createAppMetaFromAppStoreApp(appArg: TAppStoreApp): interfaces.appstore.IAppStoreAppMeta {
    return {
      id: appArg.id,
      name: appArg.name,
      description: appArg.description,
      category: appArg.category,
      iconName: appArg.iconName,
      latestVersion: appArg.latestVersion,
      versions: appArg.versions || [appArg.latestVersion],
      tags: appArg.tags,
      source: appArg.source,
      resolvedSource: appArg.resolvedSource,
    };
  }

  private async getAppStoreApp(appIdArg: string): Promise<TAppStoreApp | undefined> {
    const appStore = await this.getAppStoreIndex();
    return appStore.apps.find((appArg) => appArg.id === appIdArg);
  }

  private async fetchJson(pathArg: string): Promise<unknown> {
    const url = `${this.baseUrl}/${pathArg}`;
    const response = await this.fetchRef(url);
    if (!response.ok) {
      throw new Error(`HTTP ${response.status} for ${url}`);
    }
    return response.json();
  }

  private async fetchTextFromUrl(urlArg: string): Promise<string> {
    const response = await this.fetchRef(urlArg);
    if (!response.ok) {
      throw new Error(`HTTP ${response.status} for ${urlArg}`);
    }
    return response.text();
  }

  private async fetchDockerManifestDigest(imageArg: IParsedDockerImageReference): Promise<string | null> {
    const manifestUrl = `https://${imageArg.registry}/v2/${imageArg.repository}/manifests/${imageArg.tag}`;
    const headers = new Headers({
      Accept: [
        'application/vnd.docker.distribution.manifest.v2+json',
        'application/vnd.oci.image.manifest.v1+json',
        'application/vnd.docker.distribution.manifest.list.v2+json',
        'application/vnd.oci.image.index.v1+json',
      ].join(', '),
    });

    let response = await this.fetchRef(manifestUrl, { method: 'HEAD', headers });
    if (response.status === 401) {
      const authHeader = response.headers.get('www-authenticate');
      const token = authHeader ? await this.fetchDockerRegistryToken(authHeader, imageArg.repository) : null;
      if (token) {
        headers.set('Authorization', `Bearer ${token}`);
        response = await this.fetchRef(manifestUrl, { method: 'HEAD', headers });
      }
    }

    if (!response.ok || !response.headers.get('docker-content-digest')) {
      response = await this.fetchRef(manifestUrl, { method: 'GET', headers });
    }

    if (!response.ok) {
      throw new Error(`HTTP ${response.status} while resolving ${imageArg.repository}:${imageArg.tag}`);
    }

    return response.headers.get('docker-content-digest');
  }

  private async fetchDockerRegistryToken(authHeaderArg: string, repositoryArg: string): Promise<string | null> {
    const match = authHeaderArg.match(/^Bearer\s+(.+)$/i);
    if (!match) return null;

    const authParams = new Map<string, string>();
    for (const partArg of match[1].match(/(?:[^,\"]+|\"[^\"]*\")+/g) || []) {
      const [key, rawValue] = partArg.split('=');
      if (!key || rawValue === undefined) continue;
      authParams.set(key.trim(), rawValue.trim().replace(/^\"|\"$/g, ''));
    }

    const realm = authParams.get('realm');
    if (!realm) return null;
    const tokenUrl = new URL(realm);
    const service = authParams.get('service');
    const scope = authParams.get('scope') || `repository:${repositoryArg}:pull`;
    if (service) tokenUrl.searchParams.set('service', service);
    tokenUrl.searchParams.set('scope', scope);

    const response = await this.fetchRef(tokenUrl.toString());
    if (!response.ok) return null;
    const tokenResponse = await response.json() as { token?: string; access_token?: string };
    return tokenResponse.token || tokenResponse.access_token || null;
  }

  private validateVolume(volumeArg: interfaces.appstore.IAppStoreVolume, labelArg: string): void {
    if (!volumeArg.mountPath || !volumeArg.mountPath.startsWith('/')) {
      throw new Error(`Invalid ${labelArg}: mountPath must be an absolute path`);
    }
    if (volumeArg.mountPath.includes(':')) {
      throw new Error(`Invalid ${labelArg}: mountPath must not contain ':'`);
    }
    if ((volumeArg.source || volumeArg.name)?.includes(':')) {
      throw new Error(`Invalid ${labelArg}: source/name must not contain ':'`);
    }
  }

  private validatePublishedPorts(
    publishedPortsArg: TAppStoreVersionConfig['publishedPorts'] = [],
    labelArg: string,
  ): void {
    const seenPublishedPorts = new Set<string>();
    for (const portArg of publishedPortsArg) {
      const protocol = portArg.protocol || 'tcp';
      const targetStart = portArg.targetPort;
      const targetEnd = portArg.targetPortEnd || targetStart;
      const publishedStart = portArg.publishedPort || targetStart;
      const publishedEnd = portArg.publishedPortEnd || (publishedStart + (targetEnd - targetStart));
      const hostIp = portArg.hostIp || '0.0.0.0';

      if (!['tcp', 'udp'].includes(protocol)) {
        throw new Error(`Invalid ${labelArg}: published port protocol '${protocol}' is not supported`);
      }
      this.assertValidPort(targetStart, `${labelArg} targetPort`);
      this.assertValidPort(targetEnd, `${labelArg} targetPortEnd`);
      this.assertValidPort(publishedStart, `${labelArg} publishedPort`);
      this.assertValidPort(publishedEnd, `${labelArg} publishedPortEnd`);
      if (targetEnd < targetStart || publishedEnd < publishedStart) {
        throw new Error(`Invalid ${labelArg}: published port ranges must be ascending`);
      }
      if ((targetEnd - targetStart) !== (publishedEnd - publishedStart)) {
        throw new Error(`Invalid ${labelArg}: target and published port ranges must have the same size`);
      }
      if ((targetEnd - targetStart) > 1000) {
        throw new Error(`Invalid ${labelArg}: published port ranges may not exceed 1001 ports`);
      }

      for (let offset = 0; offset <= targetEnd - targetStart; offset++) {
        const publishedPort = publishedStart + offset;
        const publishedKey = `${hostIp}/${protocol}/${publishedPort}`;
        const wildcardKey = `0.0.0.0/${protocol}/${publishedPort}`;
        const conflictsWithWildcard = hostIp === '0.0.0.0'
          ? Array.from(seenPublishedPorts).some((keyArg) => keyArg.endsWith(`/${protocol}/${publishedPort}`))
          : seenPublishedPorts.has(wildcardKey);
        if (seenPublishedPorts.has(publishedKey) || conflictsWithWildcard) {
          throw new Error(`Invalid ${labelArg}: duplicate published port ${hostIp}:${publishedPort}/${protocol}`);
        }
        seenPublishedPorts.add(publishedKey);
      }
    }
  }

  private assertValidPort(portArg: number, labelArg: string): void {
    if (!Number.isInteger(portArg) || portArg < 1 || portArg > 65535) {
      throw new Error(`Invalid ${labelArg}: ${portArg}. Expected an integer port between 1 and 65535.`);
    }
  }
}

export function parseAppStoreIndex(inputArg: unknown): TAppStoreIndex {
  const appStore = inputArg as TAppStoreIndex;
  if (!appStore || typeof appStore !== 'object' || !Array.isArray(appStore.apps)) {
    throw new Error('Invalid appstore format');
  }
  return appStore;
}

export function parseServezoneAppStoreManifest(inputArg: unknown): TServezoneAppStoreManifest {
  const manifest = inputArg as TServezoneAppStoreManifest;
  if (!manifest || typeof manifest !== 'object') {
    throw new Error('Appstore manifest must be an object');
  }
  if (manifest.schemaVersion !== 1) {
    throw new Error(`Unsupported appstore manifest schemaVersion '${manifest.schemaVersion}'`);
  }
  if (!manifest.app?.id || !manifest.app?.name) {
    throw new Error('Appstore manifest app.id and app.name are required');
  }
  return manifest;
}

export function parseDockerImageReference(imageArg: string): IParsedDockerImageReference {
  const [imageWithoutDigest, digest] = imageArg.split('@');
  const imageParts = imageWithoutDigest.split('/');
  const firstPart = imageParts[0];
  const hasExplicitRegistry = imageParts.length > 1
    && (firstPart.includes('.') || firstPart.includes(':') || firstPart === 'localhost');
  const registry = hasExplicitRegistry ? firstPart : 'registry-1.docker.io';
  const repositoryParts = hasExplicitRegistry ? imageParts.slice(1) : imageParts;
  let repositoryWithTag = repositoryParts.join('/');
  if (!repositoryWithTag) {
    throw new Error(`Invalid Docker image reference '${imageArg}'`);
  }

  if (!hasExplicitRegistry && !repositoryWithTag.includes('/')) {
    repositoryWithTag = `library/${repositoryWithTag}`;
  }

  const lastSlashIndex = repositoryWithTag.lastIndexOf('/');
  const lastColonIndex = repositoryWithTag.lastIndexOf(':');
  const hasTag = lastColonIndex > lastSlashIndex;
  const repository = hasTag ? repositoryWithTag.slice(0, lastColonIndex) : repositoryWithTag;
  const tag = hasTag ? repositoryWithTag.slice(lastColonIndex + 1) : 'latest';

  return { registry, repository, tag, digest };
}

export function createAppStoreVersionForDockerSource(
  sourceArg: TAppStoreDockerImageSource,
  fallbackVersionArg: string,
  digestArg?: string,
): string {
  if (sourceArg.tracking !== 'digest' || !digestArg) {
    return fallbackVersionArg;
  }
  const parsedImage = parseDockerImageReference(sourceArg.image);
  return `${parsedImage.tag}@${digestArg}`;
}

async function createSha256Hex(inputArg: string): Promise<string> {
  const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(inputArg));
  return Array.from(new Uint8Array(digest))
    .map((byteArg) => byteArg.toString(16).padStart(2, '0'))
    .join('');
}

function uniqueStrings(valuesArg: string[]): string[] {
  return Array.from(new Set(valuesArg.filter(Boolean)));
}

function withoutUndefined<T extends object>(objectArg: T): Partial<T> {
  return Object.fromEntries(
    Object.entries(objectArg).filter(([, valueArg]) => valueArg !== undefined),
  ) as Partial<T>;
}

function getUpgradeStrategyForConfig(
  configArg?: TAppStoreVersionConfig,
): interfaces.appstore.IAppStoreApp['upgradeStrategy'] {
  if (configArg?.upgradeStrategy) return configArg.upgradeStrategy;
  if (configArg?.source?.type === 'dockerImage' && configArg.source.tracking === 'digest') return 'dockerDigest';
  return undefined;
}