import { mergeTypeDefs } from "@graphql-tools/merge"
import { makeExecutableSchema } from "@graphql-tools/schema"
import { RemoteFetchDataCallback } from "@medusajs/orchestration"
import {
  ConfigModule,
  ExternalModuleDeclaration,
  ILinkMigrationsPlanner,
  InternalModuleDeclaration,
  LoadedModule,
  Logger,
  MedusaContainer,
  ModuleBootstrapDeclaration,
  ModuleDefinition,
  ModuleExports,
  ModuleJoinerConfig,
  ModuleServiceInitializeOptions,
  RemoteJoinerOptions,
  RemoteJoinerQuery,
  RemoteQueryFunction,
} from "@medusajs/types"
import {
  ContainerRegistrationKeys,
  MedusaError,
  ModuleRegistrationName,
  Modules,
  ModulesSdkUtils,
  createMedusaContainer,
  isObject,
  isString,
  promiseAll,
} from "@medusajs/utils"
import type { Knex } from "@mikro-orm/knex"
import { asValue } from "awilix"
import { MODULE_PACKAGE_NAMES } from "./definitions"
import {
  MedusaModule,
  MigrationOptions,
  RegisterModuleJoinerConfig,
} from "./medusa-module"
import { RemoteLink } from "./remote-link"
import { RemoteQuery } from "./remote-query"
import { MODULE_RESOURCE_TYPE, MODULE_SCOPE } from "./types"
import { cleanGraphQLSchema } from "./utils"

const LinkModulePackage = MODULE_PACKAGE_NAMES[Modules.LINK]

declare module "@medusajs/types" {
  export interface ModuleImplementations {
    [ContainerRegistrationKeys.REMOTE_LINK]: RemoteLink
    [ContainerRegistrationKeys.CONFIG_MODULE]: ConfigModule
    [ContainerRegistrationKeys.PG_CONNECTION]: Knex<any>
    [ContainerRegistrationKeys.REMOTE_QUERY]: RemoteQueryFunction
    [ContainerRegistrationKeys.LOGGER]: Logger
  }
}

export type RunMigrationFn = () => Promise<void>
export type RevertMigrationFn = (moduleNames: string[]) => Promise<void>
export type GenerateMigrations = (moduleNames: string[]) => Promise<void>
export type GetLinkExecutionPlanner = () => ILinkMigrationsPlanner

export type MedusaModuleConfig = {
  [key: string | Modules]:
    | string
    | boolean
    | Partial<InternalModuleDeclaration | ExternalModuleDeclaration>
}

export type SharedResources = {
  database?: ModuleServiceInitializeOptions["database"] & {
    /**
     * {
     *   name?: string
     *   afterCreate?: Function
     *   min?: number
     *   max?: number
     *   refreshIdle?: boolean
     *   idleTimeoutMillis?: number
     *   reapIntervalMillis?: number
     *   returnToHead?: boolean
     *   priorityRange?: number
     *   log?: (message: string, logLevel: string) => void
     * }
     */
    pool?: Record<string, unknown>
  }
}

export async function loadModules(
  modulesConfig,
  sharedContainer,
  migrationOnly = false,
  loaderOnly = false,
  workerMode: "shared" | "worker" | "server" = "server"
) {
  const allModules = {}

  await Promise.all(
    Object.keys(modulesConfig).map(async (moduleName) => {
      const mod = modulesConfig[moduleName]
      let path: string
      let moduleExports: ModuleExports | undefined = undefined
      let declaration: any = {}
      let definition: Partial<ModuleDefinition> | undefined = undefined

      if (isObject(mod)) {
        const mod_ = mod as unknown as InternalModuleDeclaration
        path = mod_.resolve ?? MODULE_PACKAGE_NAMES[moduleName]
        definition = mod_.definition
        moduleExports = !isString(mod_.resolve)
          ? (mod_.resolve as ModuleExports)
          : undefined
        declaration = { ...mod }
        delete declaration.definition
      } else {
        path = MODULE_PACKAGE_NAMES[moduleName]
      }

      declaration.scope ??= MODULE_SCOPE.INTERNAL
      if (
        declaration.scope === MODULE_SCOPE.INTERNAL &&
        !declaration.resources
      ) {
        declaration.resources = MODULE_RESOURCE_TYPE.SHARED
      }

      const loaded = (await MedusaModule.bootstrap({
        moduleKey: moduleName,
        defaultPath: path,
        declaration,
        sharedContainer,
        moduleDefinition: definition as ModuleDefinition,
        moduleExports,
        migrationOnly,
        loaderOnly,
        workerMode,
      })) as LoadedModule

      if (loaderOnly) {
        return
      }

      const service = loaded[moduleName]
      sharedContainer.register({
        [service.__definition.registrationName]: asValue(service),
      })

      if (allModules[moduleName] && !Array.isArray(allModules[moduleName])) {
        allModules[moduleName] = []
      }

      if (allModules[moduleName]) {
        ;(allModules[moduleName] as LoadedModule[]).push(loaded[moduleName])
      } else {
        allModules[moduleName] = loaded[moduleName]
      }
    })
  )
  return allModules
}

async function initializeLinks({
  config,
  linkModules,
  injectedDependencies,
  moduleExports,
}) {
  try {
    const { initialize, getMigrationPlanner } =
      moduleExports ?? (await import(LinkModulePackage))

    const linkResolution = await initialize(
      config,
      linkModules,
      injectedDependencies
    )

    return {
      remoteLink: new RemoteLink(),
      linkResolution,
      getMigrationPlanner,
    }
  } catch (err) {
    console.warn("Error initializing link modules.", err)
    return {
      remoteLink: undefined,
      linkResolution: undefined,
      getMigrationPlanner: () => void 0,
    }
  }
}

function isMedusaModule(mod) {
  return typeof mod?.initialize === "function"
}

function cleanAndMergeSchema(loadedSchema) {
  const defaultMedusaSchema = `
    scalar DateTime
    scalar JSON
  `
  const { schema: cleanedSchema, notFound } = cleanGraphQLSchema(
    defaultMedusaSchema + loadedSchema
  )
  const mergedSchema = mergeTypeDefs(cleanedSchema)
  return { schema: makeExecutableSchema({ typeDefs: mergedSchema }), notFound }
}

function getLoadedSchema(): string {
  return MedusaModule.getAllJoinerConfigs()
    .map((joinerConfig) => joinerConfig?.schema ?? "")
    .join("\n")
}

function registerCustomJoinerConfigs(servicesConfig: ModuleJoinerConfig[]) {
  for (const config of servicesConfig) {
    if (!config.serviceName || config.isReadOnlyLink) {
      continue
    }

    MedusaModule.setJoinerConfig(config.serviceName, config)
  }
}

export type MedusaAppOutput = {
  modules: Record<string, LoadedModule | LoadedModule[]>
  link: RemoteLink | undefined
  query: RemoteQueryFunction
  entitiesMap?: Record<string, any>
  notFound?: Record<string, Record<string, string>>
  runMigrations: RunMigrationFn
  revertMigrations: RevertMigrationFn
  generateMigrations: GenerateMigrations
  linkMigrationExecutionPlanner: GetLinkExecutionPlanner
  onApplicationShutdown: () => Promise<void>
  onApplicationPrepareShutdown: () => Promise<void>
  onApplicationStart: () => Promise<void>
  sharedContainer?: MedusaContainer
}

export type MedusaAppOptions = {
  workerMode?: "shared" | "worker" | "server"
  sharedContainer?: MedusaContainer
  sharedResourcesConfig?: SharedResources
  loadedModules?: LoadedModule[]
  servicesConfig?: ModuleJoinerConfig[]
  modulesConfigPath?: string
  modulesConfigFileName?: string
  modulesConfig?: MedusaModuleConfig
  linkModules?: RegisterModuleJoinerConfig | RegisterModuleJoinerConfig[]
  remoteFetchData?: RemoteFetchDataCallback
  injectedDependencies?: any
  onApplicationStartCb?: () => void
  /**
   * Forces the modules bootstrapper to only run the modules loaders and return prematurely
   */
  loaderOnly?: boolean
}

async function MedusaApp_({
  sharedContainer,
  sharedResourcesConfig,
  servicesConfig,
  modulesConfigPath,
  modulesConfigFileName,
  modulesConfig,
  linkModules,
  remoteFetchData,
  injectedDependencies = {},
  migrationOnly = false,
  loaderOnly = false,
  workerMode = "server",
}: MedusaAppOptions & {
  migrationOnly?: boolean
} = {}): Promise<MedusaAppOutput> {
  const sharedContainer_ = createMedusaContainer({}, sharedContainer)

  const onApplicationShutdown = async () => {
    await promiseAll([
      MedusaModule.onApplicationShutdown(),
      sharedContainer_.dispose(),
    ])
  }

  const onApplicationPrepareShutdown = async () => {
    await promiseAll([MedusaModule.onApplicationPrepareShutdown()])
  }

  const onApplicationStart = async () => {
    await MedusaModule.onApplicationStart()
  }

  const modules: MedusaModuleConfig =
    modulesConfig ??
    (
      await import(
        modulesConfigPath ??
          process.cwd() + (modulesConfigFileName ?? "/modules-config")
      )
    ).default

  const dbData = ModulesSdkUtils.loadDatabaseConfig(
    "medusa",
    sharedResourcesConfig as ModuleServiceInitializeOptions,
    true
  )!

  registerCustomJoinerConfigs(servicesConfig ?? [])

  if (
    sharedResourcesConfig?.database?.connection &&
    !injectedDependencies[ContainerRegistrationKeys.PG_CONNECTION]
  ) {
    injectedDependencies[ContainerRegistrationKeys.PG_CONNECTION] =
      sharedResourcesConfig.database.connection
  } else if (
    dbData.clientUrl &&
    !injectedDependencies[ContainerRegistrationKeys.PG_CONNECTION]
  ) {
    injectedDependencies[ContainerRegistrationKeys.PG_CONNECTION] =
      ModulesSdkUtils.createPgConnection({
        ...(sharedResourcesConfig?.database ?? {}),
        ...dbData,
      })
  }

  // remove the link module from the modules
  const linkModule = modules[LinkModulePackage] ?? modules[Modules.LINK]
  delete modules[LinkModulePackage]
  delete modules[Modules.LINK]

  let linkModuleOrOptions:
    | Partial<ModuleServiceInitializeOptions>
    | Partial<ModuleBootstrapDeclaration> = {}

  if (isObject(linkModule)) {
    linkModuleOrOptions = linkModule
  }

  for (const injectedDependency of Object.keys(injectedDependencies)) {
    sharedContainer_.register({
      [injectedDependency]: asValue(injectedDependencies[injectedDependency]),
    })
  }

  const allModules = await loadModules(
    modules,
    sharedContainer_,
    migrationOnly,
    loaderOnly,
    workerMode
  )

  if (loaderOnly) {
    return {
      onApplicationShutdown,
      onApplicationPrepareShutdown,
      onApplicationStart,
      modules: allModules,
      link: undefined,
      query: async () => {
        throw new Error("Querying not allowed in loaderOnly mode")
      },
      runMigrations: async () => {
        throw new Error("Migrations not allowed in loaderOnly mode")
      },
      revertMigrations: async () => {
        throw new Error("Revert migrations not allowed in loaderOnly mode")
      },
      generateMigrations: async () => {
        throw new Error("Generate migrations not allowed in loaderOnly mode")
      },
      linkMigrationExecutionPlanner: () => {
        throw new Error(
          "Migrations planner is not avaibable in loaderOnly mode"
        )
      },
    }
  }

  // Share Event bus with link modules
  injectedDependencies[ModuleRegistrationName.EVENT_BUS] =
    sharedContainer_.resolve(ModuleRegistrationName.EVENT_BUS, {
      allowUnregistered: true,
    })

  linkModules ??= []
  if (!Array.isArray(linkModules)) {
    linkModules = [linkModules]
  }
  linkModules.push(...MedusaModule.getCustomLinks())

  const allLoadedJoinerConfigs = MedusaModule.getAllJoinerConfigs()
  for (let linkIdx = 0; linkIdx < linkModules.length; linkIdx++) {
    const customLink: any = linkModules[linkIdx]
    if (typeof customLink === "function") {
      linkModules[linkIdx] = customLink(allLoadedJoinerConfigs)
    }
  }

  const { remoteLink, getMigrationPlanner } = await initializeLinks({
    config: linkModuleOrOptions,
    linkModules,
    injectedDependencies,
    moduleExports: isMedusaModule(linkModule) ? linkModule : undefined,
  })

  const loadedSchema = getLoadedSchema()
  const { schema, notFound } = cleanAndMergeSchema(loadedSchema)

  const remoteQuery = new RemoteQuery({
    servicesConfig,
    customRemoteFetchData: remoteFetchData,
  })

  const query = async (
    query: string | RemoteJoinerQuery | object,
    variables?: Record<string, unknown>,
    options?: RemoteJoinerOptions
  ) => {
    return await remoteQuery.query(query, variables, options)
  }

  const applyMigration = async ({
    modulesNames,
    action = "run",
  }: {
    modulesNames: string[]
    action?: "run" | "revert" | "generate"
  }) => {
    const moduleResolutions = modulesNames.map((moduleName) => {
      return {
        moduleName,
        resolution: MedusaModule.getModuleResolutions(moduleName),
      }
    })

    const missingModules = moduleResolutions
      .filter(({ resolution }) => !resolution)
      .map(({ moduleName }) => moduleName)

    if (missingModules.length) {
      const error = new MedusaError(
        MedusaError.Types.UNKNOWN_MODULES,
        `Cannot ${action} migrations for unknown module(s) ${missingModules.join(
          ","
        )}`,
        MedusaError.Codes.UNKNOWN_MODULES
      )
      error["allModules"] = Object.keys(allModules)
      throw error
    }

    for (const { resolution: moduleResolution } of moduleResolutions) {
      if (!moduleResolution.options?.database) {
        moduleResolution.options ??= {}
        moduleResolution.options.database = {
          ...(sharedResourcesConfig?.database ?? {}),
        }
      }

      const migrationOptions: MigrationOptions = {
        moduleKey: moduleResolution.definition.key,
        modulePath: moduleResolution.resolutionPath as string,
        container: sharedContainer,
        options: moduleResolution.options,
        moduleExports: moduleResolution.moduleExports,
      }

      if (action === "revert") {
        await MedusaModule.migrateDown(migrationOptions)
      } else if (action === "run") {
        await MedusaModule.migrateUp(migrationOptions)
      } else {
        await MedusaModule.migrateGenerate(migrationOptions)
      }
    }
  }

  const runMigrations: RunMigrationFn = async (): Promise<void> => {
    await applyMigration({
      modulesNames: Object.keys(allModules),
    })
  }

  const revertMigrations: RevertMigrationFn = async (
    modulesNames
  ): Promise<void> => {
    await applyMigration({
      modulesNames,
      action: "revert",
    })
  }

  const generateMigrations: GenerateMigrations = async (
    modulesNames
  ): Promise<void> => {
    await applyMigration({
      modulesNames,
      action: "generate",
    })
  }

  const getMigrationPlannerFn = () => {
    const options: Partial<ModuleServiceInitializeOptions> =
      "scope" in linkModuleOrOptions
        ? { ...linkModuleOrOptions.options }
        : {
            ...(linkModuleOrOptions as Partial<ModuleServiceInitializeOptions>),
          }

    options.database ??= {
      ...sharedResourcesConfig?.database,
    }

    return getMigrationPlanner(options, linkModules)
  }

  return {
    onApplicationShutdown,
    onApplicationPrepareShutdown,
    onApplicationStart,
    modules: allModules,
    link: remoteLink,
    query,
    entitiesMap: schema.getTypeMap(),
    notFound,
    runMigrations,
    revertMigrations,
    generateMigrations,
    linkMigrationExecutionPlanner: getMigrationPlannerFn,
    sharedContainer: sharedContainer_,
  }
}

export async function MedusaApp(
  options: MedusaAppOptions = {}
): Promise<MedusaAppOutput> {
  return await MedusaApp_(options)
}

export async function MedusaAppMigrateUp(
  options: MedusaAppOptions = {}
): Promise<void> {
  const migrationOnly = true

  const { runMigrations } = await MedusaApp_({
    ...options,
    migrationOnly,
  })

  await runMigrations().finally(MedusaModule.clearInstances)
}

export async function MedusaAppMigrateDown(
  moduleNames: string[],
  options: MedusaAppOptions = {}
): Promise<void> {
  const migrationOnly = true

  const { revertMigrations } = await MedusaApp_({
    ...options,
    migrationOnly,
  })

  await revertMigrations(moduleNames).finally(MedusaModule.clearInstances)
}

export async function MedusaAppMigrateGenerate(
  moduleNames: string[],
  options: MedusaAppOptions = {}
): Promise<void> {
  const migrationOnly = true

  const { generateMigrations } = await MedusaApp_({
    ...options,
    migrationOnly,
  })

  await generateMigrations(moduleNames).finally(MedusaModule.clearInstances)
}

export async function MedusaAppGetLinksExecutionPlanner(
  options: MedusaAppOptions = {}
): Promise<ILinkMigrationsPlanner> {
  const migrationOnly = true

  const { linkMigrationExecutionPlanner } = await MedusaApp_({
    ...options,
    migrationOnly,
  })

  return linkMigrationExecutionPlanner()
}