import os from "os";
import { Client, CredentialManager } from "@atcute/client";
import { getPdsEndpoint } from "@atcute/identity";
import {
  CompositeDidDocumentResolver,
  PlcDidDocumentResolver,
  WebDidDocumentResolver,
} from "@atcute/identity-resolver";
import { config } from "./config";
import type {} from "@atcute/atproto";
import {
  applyMiddleware,
  applyMiddlewareAll,
  getRecord,
  log,
  ok,
  putRecord,
  type Middleware,
  type Result,
} from "./utils";
import store from "./store";
import routes from "./routes";
import { handleEvents } from "./jetstream";

const docResolver = new CompositeDidDocumentResolver({
  methods: {
    plc: new PlcDidDocumentResolver(),
    web: new WebDidDocumentResolver(),
  },
});

const pdsUrl = getPdsEndpoint(await docResolver.resolve(config.repoDid));
if (pdsUrl === undefined) {
  throw `no pds found`;
}
console.info(`pds is ${pdsUrl}`);

const creds = new CredentialManager({ service: pdsUrl });
const session = await creds.login({
  identifier: config.repoDid,
  password: config.appPass,
});
export const atpClient = new Client({ handler: creds });

// fetch host record for this host
const maybeRecord = await getRecord(
  "systems.gaze.barometer.host",
  store.hostname,
);
if (maybeRecord.ok) {
  store.host = maybeRecord.value;
}

// if it doesnt exist we make a new one
if (store.host === null) {
  await putRecord(
    {
      $type: "systems.gaze.barometer.host",
      name: config.hostName ?? store.hostname,
      description: config.hostDescription,
      os: os.platform(),
    },
    store.hostname,
  );
}

const traceRequest: Middleware = async (req) => {
  const url = new URL(req.url);
  log.info(`${req.method} ${url.pathname}`);
  return req;
};
const server = Bun.serve({
  routes: applyMiddlewareAll([traceRequest], routes),
});

console.log(`server running on http://localhost:${server.port}`);

await handleEvents();