import {
  type GitActionProgressEvent,
  type GitListBranchesResult,
  type GitResolvePullRequestResult,
  type GitRunStackedActionInput,
  type GitRunStackedActionResult,
  type GitStatusResult,
  WS_METHODS,
} from "@t3tools/contracts";
import { Duration, Effect, Stream } from "effect";
import { AsyncResult, Atom, Reactivity } from "effect/unstable/reactivity";

import { refreshIntervalSignalAtom, WsRpcAtomClient } from "./client";
import { REACTIVITY_KEYS } from "./client";
import { useMemo } from "react";
import { useAtomValue } from "@effect/atom-react";

const GIT_ACTION_RESULT_MISSING_ERROR = {
  _tag: "GitActionResultMissing",
  message: "Git action stream completed without a final result.",
} as const;
export const gitRunStackedActionProgressAtom = Atom.make<GitActionProgressEvent | null>(null).pipe(
  Atom.keepAlive,
  Atom.withLabel("git-run-stacked-action-progress"),
);

const gitStatusQueryAtom = Atom.family((cwd: string) =>
  WsRpcAtomClient.query(
    WS_METHODS.gitStatus,
    { cwd },
    {
      timeToLive: "5 minutes",
      reactivityKeys: [REACTIVITY_KEYS.git(cwd)],
    },
  ),
);

export const gitStatusAtom = Atom.family((cwd: string | null) =>
  Atom.readable(
    (get): AsyncResult.AsyncResult<GitStatusResult, unknown> => {
      if (cwd === null) {
        return AsyncResult.initial();
      }
      return get(gitStatusQueryAtom(cwd));
    },
    (refresh) => {
      if (cwd !== null) {
        refresh(gitStatusQueryAtom(cwd));
      }
    },
  ),
);

const gitBranchesQueryAtom = Atom.family((cwd: string) =>
  WsRpcAtomClient.query(
    WS_METHODS.gitListBranches,
    { cwd },
    {
      timeToLive: "5 minutes",
      reactivityKeys: [REACTIVITY_KEYS.git(cwd)],
    },
  ),
);

export const gitBranchesAtom = Atom.family((cwd: string | null) =>
  Atom.readable(
    (get): AsyncResult.AsyncResult<GitListBranchesResult, unknown> => {
      if (cwd === null) {
        return AsyncResult.initial();
      }
      return get(gitBranchesQueryAtom(cwd));
    },
    (refresh) => {
      if (cwd !== null) {
        refresh(gitBranchesQueryAtom(cwd));
      }
    },
  ),
);

export const gitCheckoutMutationAtom = WsRpcAtomClient.mutation(WS_METHODS.gitCheckout);

export const gitCreateBranchMutationAtom = WsRpcAtomClient.mutation(WS_METHODS.gitCreateBranch);

export const gitCreateWorktreeMutationAtom = WsRpcAtomClient.mutation(WS_METHODS.gitCreateWorktree);

export const gitInitMutationAtom = WsRpcAtomClient.mutation(WS_METHODS.gitInit);

export const gitPreparePullRequestThreadMutationAtom = WsRpcAtomClient.mutation(
  WS_METHODS.gitPreparePullRequestThread,
);

export const gitPullMutationAtom = WsRpcAtomClient.mutation(WS_METHODS.gitPull);

export const gitRemoveWorktreeMutationAtom = WsRpcAtomClient.mutation(WS_METHODS.gitRemoveWorktree);

export const gitRunStackedActionMutationAtom = WsRpcAtomClient.runtime
  .fn<GitRunStackedActionInput>()(
    Effect.fn(
      function* (input, get) {
        get.set(gitRunStackedActionProgressAtom, null);
        const client = yield* WsRpcAtomClient;
        return yield* client(WS_METHODS.gitRunStackedAction, input).pipe(
          Stream.runFoldEffect(
            () => null as GitRunStackedActionResult | null,
            (result, event) =>
              Effect.sync(() => {
                get.set(gitRunStackedActionProgressAtom, event);
                return event.kind === "action_finished" ? event.result : result;
              }),
          ),
          Effect.flatMap((result) =>
            result !== null ? Effect.succeed(result) : Effect.fail(GIT_ACTION_RESULT_MISSING_ERROR),
          ),
        );
      },
      (effect, input) =>
        Effect.ensuring(effect, Reactivity.invalidate([REACTIVITY_KEYS.git(input.cwd)])),
    ),
  )
  .pipe(Atom.withLabel("git-run-stacked-action"));

const gitResolvePullRequestQueryAtom = Atom.family(
  (key: { readonly cwd: string; readonly reference: string }) =>
    WsRpcAtomClient.query(WS_METHODS.gitResolvePullRequest, key, {
      timeToLive: "30 minutes",
      reactivityKeys: [REACTIVITY_KEYS.git(key.cwd)],
    }),
);

export const gitResolvePullRequestAtom = Atom.family(
  (input: { readonly cwd: string | null; readonly reference: string | null }) =>
    Atom.readable(
      (get): AsyncResult.AsyncResult<GitResolvePullRequestResult, unknown> => {
        if (input.cwd === null || input.reference === null) {
          return AsyncResult.initial();
        }
        return get(
          gitResolvePullRequestQueryAtom({
            cwd: input.cwd,
            reference: input.reference,
          }),
        );
      },
      (refresh) => {
        if (input.cwd !== null && input.reference !== null) {
          refresh(
            gitResolvePullRequestQueryAtom({
              cwd: input.cwd,
              reference: input.reference,
            }),
          );
        }
      },
    ),
);

export function useGitStatuses(
  cwds: ReadonlyArray<string>,
): ReadonlyArray<AsyncResult.AsyncResult<GitStatusResult, unknown>> {
  const atoms = useMemo(() => {
    const refreshInterval = refreshIntervalSignalAtom(Duration.seconds(60));
    return cwds.map((cwd) => gitStatusAtom(cwd).pipe(Atom.makeRefreshOnSignal(refreshInterval)));
  }, [cwds]);
  const statusesAtom = useMemo(
    () => Atom.readable((get) => atoms.map((atom) => get(atom))),
    [atoms],
  );
  return useAtomValue(statusesAtom);
}