flxn-app/src/features/players/server.ts

import { setUserMetadata, superTokensFunctionMiddleware, verifySuperTokensSession } from "@/utils/supertokens";
import { createServerFn } from "@tanstack/react-start";
import { playerInputSchema, playerUpdateSchema } from "@/features/players/types";
import { pbAdmin } from "@/lib/pocketbase/client";
import { z } from "zod";
import { logger } from ".";
import { getWebRequest } from "@tanstack/react-start/server";

export const fetchMe = createServerFn()
  .handler(async ({ response }) => {
    const request = getWebRequest();
    const { context } = await verifySuperTokensSession(request, response);

    if (!context || !context.userAuthId) return { user: undefined, roles: [], metadata: {} };

    try {
      await pbAdmin.authPromise;
      const result = await pbAdmin.getPlayerByAuthId(context.userAuthId);
      logger.info('Fetched player', result);
      return {
        user: result || undefined, 
        roles: context.roles, 
        metadata: context.metadata 
      };
    } catch (error) {
      logger.error('Error fetching player:', error);
      return { user: undefined, roles: context.roles, metadata: context.metadata };
    }
  });

export const getPlayer = createServerFn()
  .validator(z.string())
  .middleware([superTokensFunctionMiddleware])
  .handler(async ({ data }) => {
    try {
      const player = await pbAdmin.getPlayer(data);
      return player;
    } catch (error) {
      logger.error('Error getting player', error);
      return undefined;
    }
  });

export const updatePlayer = createServerFn()
  .validator(playerUpdateSchema)
  .middleware([superTokensFunctionMiddleware])
  .handler(async ({ context, data }) => {
    const userAuthId = (context as any).userAuthId;
    if (!userAuthId) return;

    try {
      // Find the player by authId first
      const existing = await pbAdmin.getPlayerByAuthId(userAuthId);

      if (!existing) return;

      // Update the player
      const updatedPlayer = await pbAdmin.updatePlayer(
        existing.id!,
        {
          first_name: data.first_name,
          last_name: data.last_name
        }
      );

      logger.info('Updated player name', updatedPlayer);

      await setUserMetadata({ data: { first_name: data.first_name, last_name: data.last_name } });

      return updatedPlayer;
    } catch (error) {
      logger.error('Error updating player name', error);
      return undefined;
    }
  });

export const createPlayer = createServerFn()
  .validator(playerInputSchema)
  .middleware([superTokensFunctionMiddleware])
  .handler(async ({ context, data }) => {
    const userAuthId = (context as any).userAuthId;
    if (!userAuthId) return;

    try {
      const existing = await pbAdmin.getPlayerByAuthId(userAuthId);
      if (existing) return;

      logger.info('Creating player', data, userAuthId);

      const newPlayer = await pbAdmin.createPlayer({
        auth_id: userAuthId,
        first_name: data.first_name,
        last_name: data.last_name
      });

      await setUserMetadata({ data: { first_name: data.first_name, last_name: data.last_name, player_id: newPlayer?.id?.toString() } });
      logger.info('Created player', newPlayer);
      return newPlayer;
    } catch (error) {
      logger.error('Error creating player', error);
      return undefined;
    }
  });

export const associatePlayer = createServerFn()
  .validator(z.string())
  .middleware([superTokensFunctionMiddleware])
  .handler(async ({ context, data }) => {
    const userAuthId = (context as any).userAuthId;
    if (!userAuthId) return;

    try {
      await pbAdmin.updatePlayer(data, {
        auth_id: userAuthId
      });

      await setUserMetadata({ data: { player_id: data } });

      const player = await pbAdmin.getPlayer(data);
      logger.info('Associated player', player);
      return player;
    } catch (error) {
      logger.error('Error associating player', error);
      return undefined;
    }
  });

export const listPlayers = createServerFn()
  .middleware([superTokensFunctionMiddleware])
  .handler(async () => {
    try {
      return await pbAdmin.listPlayers();
    } catch (error) {
      logger.error('Error listing players', error);
      return [];
    }
  });

export const getUnassociatedPlayers = createServerFn()
  .middleware([superTokensFunctionMiddleware])
  .handler(async () => {
    try {
      return await pbAdmin.getUnassociatedPlayers();
    } catch (error) {
      logger.error('Error getting unassociated players', error);
      return [];
    }
  });