import {
  withSpan,
  INSTRUMENTATION_SYMBOLS,
  type ITracer,
  type ILogger,
} from "@repo/core-shared/instrumentation";
import { marketingPagesContainer } from "./container.js";
import { MARKETING_PAGES_SYMBOLS } from "./symbols.js";
import { MockPagesRepository } from "../infrastructure/repositories/pages.repository.mock.js";
import { MockSiteSettingsRepository } from "../infrastructure/repositories/site-settings.repository.mock.js";
import { buildDevPages, buildDevSiteSettings } from "../__seeds__/dev.js";
import { getSiteSettingsUseCase } from "../application/use-cases/get-site-settings.use-case.js";
import { getPageBySlugUseCase } from "../application/use-cases/get-page-by-slug.use-case.js";
import { getSiteSettingsController } from "../interface-adapters/controllers/get-site-settings.controller.js";
import { getPageBySlugController } from "../interface-adapters/controllers/get-page-by-slug.controller.js";
import type { IPagesRepository } from "../application/repositories/pages.repository.interface.js";
import type { ISiteSettingsRepository } from "../application/repositories/site-settings.repository.interface.js";

/**
 * Replace the default empty mocks with populated ones for dev mode + storybook.
 *
 * Call this from app boot when `USE_DEV_SEED=true`, mutually exclusive with
 * `bindProductionMarketingPages(config)`. Tests must NOT call this — they
 * construct mocks directly and seed via factories per-test.
 *
 * Idempotent: safe to call multiple times; each call rebuilds fresh populated
 * repos and rebinds both symbols.
 */
export async function bindDevSeedMarketingPages(tracer: ITracer, logger: ILogger): Promise<void> {
  // Bind shared instrumentation into feature container
  if (marketingPagesContainer.isBound(INSTRUMENTATION_SYMBOLS.TRACER)) {
    marketingPagesContainer.unbind(INSTRUMENTATION_SYMBOLS.TRACER);
  }
  if (marketingPagesContainer.isBound(INSTRUMENTATION_SYMBOLS.LOGGER)) {
    marketingPagesContainer.unbind(INSTRUMENTATION_SYMBOLS.LOGGER);
  }
  marketingPagesContainer.bind<ITracer>(INSTRUMENTATION_SYMBOLS.TRACER).toConstantValue(tracer);
  marketingPagesContainer.bind<ILogger>(INSTRUMENTATION_SYMBOLS.LOGGER).toConstantValue(logger);

  // Pages repository — MockPagesRepository accepts an initial array.
  if (marketingPagesContainer.isBound(MARKETING_PAGES_SYMBOLS.IPagesRepository)) {
    marketingPagesContainer.unbind(MARKETING_PAGES_SYMBOLS.IPagesRepository);
  }
  const pagesRepo = new MockPagesRepository(buildDevPages(), tracer, logger);
  marketingPagesContainer
    .bind<IPagesRepository>(MARKETING_PAGES_SYMBOLS.IPagesRepository)
    .toConstantValue(pagesRepo);

  // Site settings repository
  if (marketingPagesContainer.isBound(MARKETING_PAGES_SYMBOLS.ISiteSettingsRepository)) {
    marketingPagesContainer.unbind(MARKETING_PAGES_SYMBOLS.ISiteSettingsRepository);
  }
  const settings = buildDevSiteSettings();
  // Inline constant so dev seed returns exactly the seeded value (not the mock's default)
  const siteSettingsRepo: ISiteSettingsRepository = {
    getSiteSettings: async () => settings,
  };
  marketingPagesContainer
    .bind<ISiteSettingsRepository>(MARKETING_PAGES_SYMBOLS.ISiteSettingsRepository)
    .toConstantValue(siteSettingsRepo);

  // Wrap use cases + controllers identically to bind-production
  const wrappedGetSiteSettings = withSpan(
    tracer,
    { name: "marketing-pages.getSiteSettings", op: "use-case" },
    getSiteSettingsUseCase(siteSettingsRepo),
  );
  const wrappedGetPageBySlug = withSpan(
    tracer,
    { name: "marketing-pages.getPageBySlug", op: "use-case" },
    getPageBySlugUseCase(pagesRepo),
  );

  for (const sym of [
    MARKETING_PAGES_SYMBOLS.IGetSiteSettingsUseCase,
    MARKETING_PAGES_SYMBOLS.IGetPageBySlugUseCase,
    MARKETING_PAGES_SYMBOLS.IGetSiteSettingsController,
    MARKETING_PAGES_SYMBOLS.IGetPageBySlugController,
  ]) {
    if (marketingPagesContainer.isBound(sym)) marketingPagesContainer.unbind(sym);
  }
  marketingPagesContainer
    .bind(MARKETING_PAGES_SYMBOLS.IGetSiteSettingsUseCase)
    .toConstantValue(wrappedGetSiteSettings);
  marketingPagesContainer
    .bind(MARKETING_PAGES_SYMBOLS.IGetPageBySlugUseCase)
    .toConstantValue(wrappedGetPageBySlug);

  marketingPagesContainer
    .bind(MARKETING_PAGES_SYMBOLS.IGetSiteSettingsController)
    .toConstantValue(
      withSpan(
        tracer,
        { name: "marketing-pages.getSiteSettings", op: "controller" },
        getSiteSettingsController(wrappedGetSiteSettings),
      ),
    );
  marketingPagesContainer
    .bind(MARKETING_PAGES_SYMBOLS.IGetPageBySlugController)
    .toConstantValue(
      withSpan(
        tracer,
        { name: "marketing-pages.getPageBySlug", op: "controller" },
        getPageBySlugController(wrappedGetPageBySlug),
      ),
    );
}