import * as Effect from "effect/Effect";
import { type StateService } from "./State.ts";

/**
 * Synchronize all state (every stack/stage/resource) from `source` into
 * `destination` so that `destination` becomes a mirror of `source`.
 *
 * For each `{ stack, stage, fqn }` present in `source`, the resource is
 * written into `destination`, overwriting any existing entry under the same
 * key. Any keys present in `destination` but absent from `source` are
 * deleted, ensuring the two stores end up structurally identical.
 *
 * Stacks are walked sequentially; stages within a stack and resources
 * within a stage are processed concurrently for throughput.
 */
export const syncState = Effect.fn(function* (
  source: StateService,
  destination: StateService,
  options?: {
    stacks?: string[];
    /**
     * Maximum number of resources to copy in parallel within a single stage.
     * @default "unbounded".
     */
    concurrency?: number | "unbounded";
  },
) {
  const concurrency = options?.concurrency ?? "unbounded";
  const [sourceStacks, destStacks] = yield* Effect.all([
    source.listStacks(),
    destination.listStacks(),
  ]);
  const sourceStackSet = new Set(
    sourceStacks.filter((stack) => options?.stacks?.includes(stack) ?? true),
  );

  yield* Effect.forEach(
    sourceStacks,
    Effect.fn(function* (stack) {
      const [sourceStages, destStages] = yield* Effect.all([
        source.listStages(stack),
        destination.listStages(stack),
      ]);
      const stages = union(sourceStages, destStages);

      yield* Effect.forEach(
        stages,
        Effect.fn(function* (stage) {
          const sourceFqns = yield* source.list({ stack, stage });
          const destFqns = yield* destination.list({ stack, stage });

          const sourceSet = new Set(sourceFqns);
          const toDelete = destFqns.filter((fqn) => !sourceSet.has(fqn));

          yield* Effect.all(
            [
              Effect.forEach(
                sourceFqns,
                Effect.fn(function* (fqn) {
                  const value = yield* source.get({ stack, stage, fqn });
                  if (value) {
                    yield* destination.set({ stack, stage, fqn, value });
                  }
                }),
                { concurrency },
              ),
              Effect.forEach(
                toDelete,
                (fqn) => destination.delete({ stack, stage, fqn }),
                { concurrency },
              ),
            ],
            { concurrency: "unbounded" },
          );
        }),
        { concurrency: "unbounded" },
      );
    }),
  );

  yield* Effect.forEach(
    destStacks.filter((stack) => !sourceStackSet.has(stack)),
    (stack) => destination.deleteStack({ stack }),
  );
});

const union = <T>(left: Iterable<T>, right: Iterable<T>) => [
  ...new Set([...left, ...right]),
];