import { type Context, Elysia, t } from "elysia";
import { NS_runtime, IS_HF } from "@x/types/env.runtime";
import { offline_store } from "@x/ff-dl/offline-store";
import { NS_promise } from "@x/core/client/promise.ts";
import { NS_error } from "@x/core/client/error.ts";
import { NS_ff_dl_stream } from "@x/ff-dl/dl-stream";
import { NS_Misc } from "@x/core/client/misc.ts";
import { redis } from "@x/post-process/cache";
import { NS_crypto_client } from "@x/core/client/crypto.ts";

const APP_ACCOUNT_ABC = () =>
  NS_runtime.ENV_VAR_DB?.APP_ACCOUNT_ABC || process.env.APP_ACCOUNT_ABC;

const APP_ENV = () => NS_runtime.ENV_VAR_DB?.APP_ENV || process.env.APP_ENV;

const REPO_ORIGIN = () =>
  NS_runtime.ENV_VAR_DB?.REPO_ORIGIN || process.env.REPO_ORIGIN;

const APP_ORIGIN = () =>
  NS_runtime.ENV_VAR_DB?.APP_ORIGIN || process?.env?.APP_ORIGIN;

const HF_BUCKET_NAME = () =>
  NS_runtime.ENV_VAR_DB?.HF_BUCKET_NAME || process.env.HF_BUCKET_NAME;

const is_dev = (() => {
  // return false;
  return APP_ENV() === "dev";
})();

const sub_router = new Elysia({ prefix: "/stream" }).get(
  "/delivery/:data_key",
  async (ctx) => {
    const { params, query, request } = ctx;
    let { data_key } = params;
    let { ops } = query;

    const REQ0 = new URL(request.url);
    const REQ_ORIGIN = (ctx as any).publicOrigin || REQ0.origin;

    const metadata = await (async () => {
      try {
        const [E_, R_] = await NS_promise.F_catch_promise({
          promise: (async () => {
            return NS_crypto_client.F_decode_unicode_v1({
              data_str: data_key,
              _is_url_safe: true,
              encoded: "hex"
            });
          })()
        });

        if (NS_Misc.F_is_record(R_)) return R_;

        if (APP_ENV() === "dev") {
          const _ = offline_store.get(data_key);

          if (_) return _;
        }

        const _ = await redis()?.get(data_key);

        return _;
      } catch {
        return;
      }
    })();

    if (!metadata) {
      return ctx.status(404, "Metadata not found");
    }

    if (ops === "raw" || ops === "decode") {
      return metadata;
    }

    const req_signal = ctx?.request.signal;

    const [E_, R_] = await NS_promise.F_catch_promise({
      promise: NS_ff_dl_stream.handle_payload({
        data_key,
        metadata,
        REQ0,
        REQ_ORIGIN,
        req_signal,
        ops
      })
    });

    if (E_) {
      const { message, status } = NS_error.F_collect_error_status_n_message({
        ERR: E_
      });

      return ctx.status(status, message);
    }

    if (typeof R_ === "object" && NS_Misc.F_is_record(R_)) {
      const _redirect = (R_ as any).redirect;

      if (_redirect) return ctx.redirect(_redirect, 302);
    }

    return R_;
  },
  {
    params: t.Object({
      data_key: t.String({
        minLength: 1,
        error() {
          return "Invalid process data, Expected string";
        }
      })
    }),
    query: t.Object({
      raw: t.Optional(
        t.Number({
          minimum: 0,
          maximum: 1,
          error: () => "Invalid raw, Expected binary boolean"
        })
      ),
      ops: t.Optional(
        t.Union(
          [
            t.Literal("cmd"),
            t.Literal("raw"),
            t.Literal("decode"),
            t.Literal("jc")
          ],
          {
            error() {
              return "Invalid operation, must be one of: cmd, raw, decode";
            }
          }
        )
      )
    })
  }
);

export const StreamRouter = sub_router;
export const StreamRouterHandlePayload = NS_ff_dl_stream.handle_payload;