import { existsSync } from 'node:fs';
import type { Nuxt } from '@nuxt/schema';
import { sn } from 'unslash';
import { findPath } from 'nuxt/kit';
import type { EruditConfig } from '@erudit-js/core/eruditConfig/config';
import { isDevLikeMode } from '@erudit-js/core/mode';

import { ERUDIT_MODE, PROJECT_PATH } from '../env.js';
import { moduleLogger } from '../logger.js';
import type {
  EruditPublicRuntimeConfig,
  EruditRuntimeConfig,
} from '../../../shared/types/runtimeConfig';

export async function setupEruditRuntimeConfig(nuxt: Nuxt) {
  let eruditConfig: EruditConfig = {};
  try {
    eruditConfig = (await import(sn(PROJECT_PATH, 'erudit.config'))).default;
  } catch (error) {
    if (existsSync(sn(PROJECT_PATH, 'erudit.config.ts'))) {
      moduleLogger.warn(
        `Config file "erudit.config.ts" is present but failed to load!\n\n${error}`,
      );
    }
  }

  //
  // Erudit Runtime Config
  //

  nuxt.options.runtimeConfig.erudit = (<EruditRuntimeConfig>{
    elements: eruditConfig.elements || [],
    countElements: eruditConfig.countElements || [],
    indexPage: eruditConfig.indexPage,
    lastmod: await resolveLastmodConfig(eruditConfig),
  }) satisfies EruditRuntimeConfig;

  //
  // Erudit Public Runtime Config
  //

  nuxt.options.runtimeConfig.public.erudit = (<EruditPublicRuntimeConfig>{
    debug: {
      ads: eruditConfig.debug?.ads ?? false,
      log: eruditConfig.debug?.log ?? false,
      slowTransition: eruditConfig.debug?.slowTransition ?? false,
      fakeApi: {
        repository:
          eruditConfig.debug?.fakeApi?.repository ??
          (nuxt.options.dev || isDevLikeMode(ERUDIT_MODE)),
      },
      analytics: eruditConfig.debug?.analytics,
    },
    language: eruditConfig.language || { current: 'en' },
    asideMajor: eruditConfig.asideMajor,
    seo: eruditConfig.seo,
    favicon: eruditConfig.favicon
      ? typeof eruditConfig.favicon === 'string'
        ? { default: eruditConfig.favicon }
        : eruditConfig.favicon
      : undefined,
    loadingSvg: eruditConfig.loadingSvg,
    style: {
      brandColor: eruditConfig.style?.brandColor,
    },
    repository: (() => {
      const repository = eruditConfig.repository;

      if (!repository) {
        return undefined;
      }

      const link = (() => {
        switch (repository.type) {
          case 'custom':
            return repository.link;
          case 'github':
            return `https://github.com/${repository.name}/tree/${repository.branch}`;
        }
      })();

      return {
        ...repository,
        _link: link,
      };
    })(),
    contributors: eruditConfig.contributors,
    sponsors: eruditConfig.sponsors,
    ads: eruditConfig.ads,
    analytics: eruditConfig.analytics,
  }) satisfies EruditPublicRuntimeConfig;

  //
  // Other
  //

  nuxt.options.runtimeConfig.public.buildTime = Date.now();

  return {
    eruditConfig,
    eruditRuntimeConfig: nuxt.options.runtimeConfig
      .erudit as EruditRuntimeConfig,
    eruditPublicRuntimeConfig: nuxt.options.runtimeConfig.public
      .erudit as EruditPublicRuntimeConfig,
    nuxtAugmentations: eruditConfig.nuxtAugmentations,
  };
}

async function resolveLastmodConfig(
  eruditConfig: EruditConfig,
): Promise<EruditRuntimeConfig['lastmod']> {
  const lastmod = eruditConfig.lastmod;

  if (!lastmod || lastmod.enabled === false) {
    return undefined;
  }

  if (lastmod.type === 'git') {
    return { type: 'git' };
  }

  if (lastmod.type === 'custom') {
    if (!lastmod.scriptPath) {
      throw new Error(
        'Lastmod config with type "custom" requires a "scriptPath"!',
      );
    }

    const absPath = await findPath(lastmod.scriptPath, {
      cwd: PROJECT_PATH,
      extensions: ['.ts', '.js'],
    });

    if (!absPath) {
      throw new Error(
        `Failed to resolve lastmod provider path "${lastmod.scriptPath}"!`,
      );
    }

    return { type: 'custom', scriptPath: absPath };
  }

  return undefined;
}