import { safeParse, type InferOutput, type RecordKey } from "@atcute/lexicons";
import { schemas as BarometerSchemas } from "barometer-lexicon";
import { config } from "./config";
import { ok as clientOk } from "@atcute/client";
import { atpClient } from ".";
import { now as generateTid } from "@atcute/tid";
import type { AtprotoDid } from "@atcute/lexicons/syntax";

export type CollectionUri<Nsid extends string> =
  `at://${AtprotoDid}/${Nsid}/${RecordKey}`;
export type StateUri = CollectionUri<"systems.gaze.barometer.state">;
export type CheckUri = CollectionUri<"systems.gaze.barometer.check">;
export type ServiceUri = CollectionUri<"systems.gaze.barometer.service">;

export const getUri = <
  Collection extends
    | "systems.gaze.barometer.state"
    | "systems.gaze.barometer.check"
    | "systems.gaze.barometer.service",
>(
  collection: Collection,
  rkey: RecordKey,
): CollectionUri<Collection> => {
  return `at://${config.repoDid}/${collection}/${rkey}`;
};

export type Result<T, E> =
  | {
      ok: true;
      value: T;
    }
  | {
      ok: false;
      error: E;
    };

export const ok = <T, E>(value: T): Result<T, E> => {
  return { ok: true, value };
};
export const err = <T, E>(error: E): Result<T, E> => {
  return { ok: false, error };
};

export const expect = <T, E>(
  v: Result<T, E>,
  msg: string = "expected result to not be error",
) => {
  if (v.ok) {
    return v.value;
  }
  throw msg;
};

export const getRecord = async <
  Collection extends keyof typeof BarometerSchemas,
>(
  collection: Collection,
  rkey: RecordKey,
): Promise<
  Result<InferOutput<(typeof BarometerSchemas)[Collection]>, string>
> => {
  let maybeRecord = await atpClient.get("com.atproto.repo.getRecord", {
    params: {
      collection,
      repo: config.repoDid,
      rkey,
    },
  });
  if (!maybeRecord.ok)
    return err(maybeRecord.data.message ?? maybeRecord.data.error);
  const maybeTyped = safeParse(
    BarometerSchemas[collection],
    maybeRecord.data.value,
  );
  if (!maybeTyped.ok) return err(maybeTyped.message);
  return maybeTyped;
};

export const putRecord = async <
  Collection extends keyof typeof BarometerSchemas,
>(
  record: InferOutput<(typeof BarometerSchemas)[Collection]>,
  rkey: RecordKey | null = null,
) => {
  return await clientOk(
    atpClient.post("com.atproto.repo.putRecord", {
      input: {
        collection: record["$type"],
        repo: config.repoDid,
        record,
        rkey: rkey ?? generateTid(),
      },
    }),
  );
};

export const log = {
  info: console.log,
  warn: console.warn,
  error: console.error,
};

export type Middleware = (
  req: Bun.BunRequest,
) => Promise<Bun.BunRequest | Response>;

export const applyMiddleware =
  <T extends string>(
    fns: Middleware[],
    route: Bun.RouterTypes.RouteHandler<T>,
  ): Bun.RouterTypes.RouteHandler<T> =>
  async (req, srv) => {
    for (const fn of fns) {
      const result = await fn(req);
      if (result instanceof Response) return result;
      else req = result;
    }
    return route(req, srv);
  };

type Routes = Record<
  string,
  Record<string, Bun.RouterTypes.RouteHandler<string>>
>;
export const applyMiddlewareAll = (
  fns: Middleware[],
  routes: Routes,
): Routes => {
  return Object.fromEntries(
    Object.entries(routes).map(([path, route]) => {
      return [
        path,
        Object.fromEntries(
          Object.entries(route).map(([method, handler]) => {
            return [method, applyMiddleware(fns, handler)];
          }),
        ),
      ];
    }),
  );
};