import * as ivs from "@distilled.cloud/aws/ivs";
import * as Data from "effect/Data";
import * as Effect from "effect/Effect";
import * as Stream from "effect/Stream";
import { Unowned } from "../../AdoptPolicy.ts";
import { createPhysicalName } from "../../PhysicalName.ts";
import * as Provider from "../../Provider.ts";
import { Resource } from "../../Resource.ts";
import { createInternalTags, hasAlchemyTags } from "../../Tags.ts";
import type { Providers } from "../Providers.ts";
import {
  retryWhileConflict,
  retryWhileThrottled,
  syncIvsTags,
  toTagRecord,
} from "./internal.ts";

export interface PlaybackRestrictionPolicyProps {
  /**
   * ISO 3166-1 alpha-2 country codes playback is allowed from. An empty
   * array denies playback from every country.
   */
  allowedCountries: string[];
  /**
   * Origins (per the HTTP `Origin` header) playback is allowed from, e.g.
   * `https://example.com`. An empty array denies playback from every
   * origin.
   */
  allowedOrigins: string[];
  /**
   * Whether to enforce the origin restriction strictly (checks the
   * viewer's origin on every video segment request, not just the initial
   * playlist request).
   * @default false
   */
  enableStrictOriginEnforcement?: boolean;
  /**
   * Name of the playback restriction policy. If omitted, a deterministic
   * physical name is generated. Names are mutable — changing the name
   * updates the policy in place.
   */
  playbackRestrictionPolicyName?: string;
  /**
   * Tags to apply to the policy. Merged with internal Alchemy tags.
   */
  tags?: Record<string, string>;
}

export interface PlaybackRestrictionPolicy extends Resource<
  "AWS.IVS.PlaybackRestrictionPolicy",
  PlaybackRestrictionPolicyProps,
  {
    /**
     * ARN of the playback restriction policy.
     */
    playbackRestrictionPolicyArn: string;
    /**
     * The policy's physical name.
     */
    playbackRestrictionPolicyName: string | undefined;
    /**
     * Country codes playback is allowed from.
     */
    allowedCountries: string[];
    /**
     * Origins playback is allowed from.
     */
    allowedOrigins: string[];
    /**
     * Whether strict origin enforcement is enabled.
     */
    enableStrictOriginEnforcement: boolean | undefined;
  },
  never,
  Providers
> {}

/**
 * An Amazon IVS playback restriction policy, constraining channel playback
 * by viewer country and/or request origin.
 *
 * Attach the policy to a channel via the channel's
 * `playbackRestrictionPolicyArn` prop. All policy settings are mutable and
 * update in place.
 * ### Restricting Playback
 * **Example:** Restrict Playback by Country and Origin
 * ```typescript
 * import * as IVS from "alchemy/AWS/IVS";
 *
 * const policy = yield* IVS.PlaybackRestrictionPolicy("GeoFence", {
 *   allowedCountries: ["US", "CA"],
 *   allowedOrigins: ["https://example.com"],
 * });
 * const channel = yield* IVS.Channel("LiveChannel", {
 *   playbackRestrictionPolicyArn: policy.playbackRestrictionPolicyArn,
 * });
 * ```
 *
 * **Example:** Strict Origin Enforcement
 * ```typescript
 * const policy = yield* IVS.PlaybackRestrictionPolicy("StrictFence", {
 *   allowedCountries: ["US"],
 *   allowedOrigins: ["https://example.com"],
 *   enableStrictOriginEnforcement: true,
 * });
 * ```
 *
 * @resource
 */
export const PlaybackRestrictionPolicy = Resource<PlaybackRestrictionPolicy>(
  "AWS.IVS.PlaybackRestrictionPolicy",
);

/**
 * Raised when the IVS API returns a playback restriction policy missing
 * its ARN.
 */
export class IvsPlaybackRestrictionPolicyIncomplete extends Data.TaggedError(
  "IvsPlaybackRestrictionPolicyIncomplete",
)<{ message: string }> {}

/** Order-insensitive equality for the policy's country/origin lists. */
const sameList = (a: readonly string[], b: readonly string[]): boolean =>
  a.length === b.length && [...a].sort().join(" ") === [...b].sort().join(" ");

export const PlaybackRestrictionPolicyProvider = () =>
  Provider.effect(
    PlaybackRestrictionPolicy,
    Effect.gen(function* () {
      const toName = (
        id: string,
        props: { playbackRestrictionPolicyName?: string | undefined },
      ) =>
        props.playbackRestrictionPolicyName
          ? Effect.succeed(props.playbackRestrictionPolicyName)
          : createPhysicalName({ id, maxLength: 128 });

      const toAttrs = (policy: ivs.PlaybackRestrictionPolicy) => ({
        playbackRestrictionPolicyArn: policy.arn,
        playbackRestrictionPolicyName: policy.name,
        allowedCountries: [...policy.allowedCountries],
        allowedOrigins: [...policy.allowedOrigins],
        enableStrictOriginEnforcement: policy.enableStrictOriginEnforcement,
      });

      const getByArn = Effect.fn(function* (arn: string) {
        const response = yield* ivs.getPlaybackRestrictionPolicy({ arn }).pipe(
          retryWhileThrottled,
          Effect.catchTag("ResourceNotFoundException", () =>
            Effect.succeed(undefined),
          ),
        );
        return response?.playbackRestrictionPolicy;
      });

      /**
       * ListPlaybackRestrictionPolicies has no name filter — enumerate and
       * match exactly, taking the first hit (names are not unique). Used
       * only when the output ARN cache is unavailable.
       */
      const findByName = Effect.fn(function* (name: string) {
        const summaries = yield* ivs.listPlaybackRestrictionPolicies
          .pages({})
          .pipe(
            Stream.runCollect,
            Effect.map((chunk) =>
              Array.from(chunk).flatMap(
                (page) => page.playbackRestrictionPolicies,
              ),
            ),
            retryWhileThrottled,
          );
        const match = summaries.find((s) => s.name === name);
        return match === undefined ? undefined : yield* getByArn(match.arn);
      });

      return {
        stables: ["playbackRestrictionPolicyArn"],

        read: Effect.fn(function* ({ id, olds, output }) {
          const policy = output?.playbackRestrictionPolicyArn
            ? yield* getByArn(output.playbackRestrictionPolicyArn)
            : yield* findByName(yield* toName(id, olds ?? {}));
          if (policy === undefined) return undefined;
          const attrs = toAttrs(policy);
          return (yield* hasAlchemyTags(id, toTagRecord(policy.tags)))
            ? attrs
            : Unowned(attrs);
        }),

        reconcile: Effect.fn(function* ({ id, news, output, session }) {
          const name = yield* toName(id, news);
          const internalTags = yield* createInternalTags(id);
          const desiredTags = { ...internalTags, ...news.tags };

          // 1. Observe — the live policy is authoritative; the output ARN
          // is only an identifier cache.
          let observed = output?.playbackRestrictionPolicyArn
            ? yield* getByArn(output.playbackRestrictionPolicyArn)
            : yield* findByName(name);

          // 2. Ensure — create if missing.
          if (observed === undefined) {
            const created = yield* ivs
              .createPlaybackRestrictionPolicy({
                name,
                allowedCountries: news.allowedCountries,
                allowedOrigins: news.allowedOrigins,
                enableStrictOriginEnforcement:
                  news.enableStrictOriginEnforcement,
                tags: desiredTags,
              })
              .pipe(retryWhileThrottled);
            observed = created.playbackRestrictionPolicy;
          }
          if (observed === undefined) {
            return yield* Effect.fail(
              new IvsPlaybackRestrictionPolicyIncomplete({
                message:
                  "IVS CreatePlaybackRestrictionPolicy returned no policy",
              }),
            );
          }
          const arn = observed.arn;

          // 3. Sync — every setting is mutable; diff observed against
          // desired and apply only the delta.
          const patch: Partial<ivs.UpdatePlaybackRestrictionPolicyRequest> = {};
          if (observed.name !== name) patch.name = name;
          if (!sameList(observed.allowedCountries, news.allowedCountries)) {
            patch.allowedCountries = news.allowedCountries;
          }
          if (!sameList(observed.allowedOrigins, news.allowedOrigins)) {
            patch.allowedOrigins = news.allowedOrigins;
          }
          if (
            news.enableStrictOriginEnforcement !== undefined &&
            (observed.enableStrictOriginEnforcement ?? false) !==
              news.enableStrictOriginEnforcement
          ) {
            patch.enableStrictOriginEnforcement =
              news.enableStrictOriginEnforcement;
          }
          if (Object.keys(patch).length > 0) {
            yield* ivs
              .updatePlaybackRestrictionPolicy({ arn, ...patch })
              .pipe(retryWhileThrottled, retryWhileConflict);
          }

          // 3b. Sync tags — diff against OBSERVED cloud tags so adoption
          // converges.
          yield* syncIvsTags(arn, desiredTags);

          // 4. Return fresh attributes.
          const final = yield* getByArn(arn);
          if (final === undefined) {
            return yield* Effect.fail(
              new IvsPlaybackRestrictionPolicyIncomplete({
                message: `IVS playback restriction policy '${arn}' vanished during reconcile`,
              }),
            );
          }
          yield* session.note(arn);
          return toAttrs(final);
        }),

        delete: Effect.fn(function* ({ output }) {
          // Deleting a policy still attached to a channel raises
          // ConflictException — retry through a bounded window (the channel
          // detaches first in a same-deploy destroy), then tolerate
          // already-gone.
          yield* ivs
            .deletePlaybackRestrictionPolicy({
              arn: output.playbackRestrictionPolicyArn,
            })
            .pipe(
              retryWhileThrottled,
              retryWhileConflict,
              Effect.catchTag("ResourceNotFoundException", () => Effect.void),
            );
        }),

        list: () =>
          ivs.listPlaybackRestrictionPolicies.pages({}).pipe(
            Stream.runCollect,
            Effect.map((chunk) =>
              Array.from(chunk).flatMap(
                (page) => page.playbackRestrictionPolicies,
              ),
            ),
            Effect.map((summaries) =>
              summaries.map((summary) => toAttrs(summary)),
            ),
          ),
      };
    }),
  );