import { ERROR } from 'bunyan';
import fs from 'fs-extra';
import * as tar from 'tar';
import { getProblems, logger } from '../../lib/logger/index.ts';
import { generateConfig } from './config.ts';
import { generateDatasources } from './datasources.ts';
import { generateEnvOptions } from './env-options.ts';
import { generateEnvVars } from './env-vars.ts';
import { getOpenGitHubItems } from './github-query-items.ts';
import { generateManagerGithubActionsCommunity } from './manager/github-actions/community.ts';
import { generateManagers } from './manager.ts';
import { generateManagerAsdfSupportedPlugins } from './manager-asdf-supported-plugins.ts';
import { generateManagerMiseSupportedPlugins } from './manager-mise-supported-plugins.ts';
import { generateDatasourceReleaseTimestampSupportForMinimumReleaseAge } from './minimum-release-age.ts';
import { generatePlatforms } from './platforms.ts';
import { generatePresets } from './presets.ts';
import { generateSchema } from './schema.ts';
import { generateTemplates } from './templates.ts';
import { generateVersioning } from './versioning.ts';

export async function generateDocs(
  root = 'tmp',
  pack = true,
  version?: string,
): Promise<void> {
  try {
    const dist = `${root}/docs`;
    logger.info(`generating docs to '${dist}'`);

    await fs.mkdir(`${dist}/`, { recursive: true });

    logger.info('* static');
    await fs.copy('docs/usage/.', `${dist}`);

    logger.info('* fetching open GitHub issues');
    const openItems = await getOpenGitHubItems();

    logger.info('* platforms');
    await generatePlatforms(dist, openItems.platforms);

    // versionings
    logger.info('* versionings');
    await generateVersioning(dist, openItems.versionings);

    // datasources
    logger.info('* datasources');
    await generateDatasources(dist, openItems.datasources);

    // minimum release age: datasource release timestamp support
    logger.info('* key-concepts/minimum-release-age');
    await generateDatasourceReleaseTimestampSupportForMinimumReleaseAge(dist);

    // managers
    logger.info('* managers');
    await generateManagers(dist, openItems.managers);

    // managers/asdf supported plugins
    logger.info('* managers/asdf/supported-plugins');
    await generateManagerAsdfSupportedPlugins(dist);

    // managers/github-actions first-party and community actions
    logger.info('* managers/github-actions/community');
    await generateManagerGithubActionsCommunity(dist);

    // managers/mise supported plugins
    logger.info('* managers/mise/supported-plugins');
    await generateManagerMiseSupportedPlugins(dist);

    // presets
    logger.info('* presets');
    await generatePresets(dist);

    // templates
    logger.info('* templates');
    await generateTemplates(dist);

    // configuration-options
    logger.info('* configuration-options');
    await generateConfig(dist);

    // self-hosted-configuration
    logger.info('* self-hosted-configuration');
    await generateConfig(dist, true);

    // env-options
    logger.info('* env-options');
    await generateEnvOptions(dist);

    // environment-variable-handling
    logger.info('* environment-variable-handling');
    await generateEnvVars(dist);

    // json-schema
    logger.info('* json-schema');
    await generateSchema(dist, { version });
    await generateSchema(dist, {
      filename: 'renovate-inherited-schema.json',
      version,
      isInherit: true,
    });
    await generateSchema(dist, {
      filename: 'renovate-global-schema.json',
      version,
      isGlobal: true,
    });

    if (pack) {
      await tar.create({ file: `${root}/docs.tgz`, cwd: dist, gzip: true }, [
        '.',
      ]);
    }
  } catch (err) {
    logger.error({ err }, 'Unexpected error');
  } finally {
    const loggerErrors = getProblems().filter((p) => p.level >= ERROR);
    if (loggerErrors.length) {
      process.exit(1);
    }
  }
}