import { useValidatedParams, z, zh } from 'h3-zod';
import prisma from '~~/lib/prisma';

export default defineEventHandler(async (event) => {
  const { questId } = await useValidatedParams(
    event,
    z.object({
      questId: zh.numAsString
    })
  );

  const user = await getUserSession(event);
  const userId = user.user?.id || 0;

  const _quest = await prisma.huntQuest.findUnique({
    where: {
      id: questId
    },
    select: {
      id: true,
      title_de: true,
      title_en: true,
      description_de: true,
      description_en: true,
      isBingo: true,
      picture: {
        select: {
          url: true
        }
      },
      question_de: true,
      question_en: true,
      optional: true,
      pictureRequired: true,
      textRequired: true,
      textType: true,
      textUnit: true,
      points: true,
      extraPoints: true,
      extraText_de: true,
      extraText_en: true,
      hunt: {
        select: {
          id: true,
          name_de: true,
          name_en: true,
          revealQuests: true,
          teams: {
            select: {
              id: true
            },
            where: {
              OR: [
                {
                  ownerId: userId
                },
                {
                  members: {
                    some: {
                      memberId: userId
                    }
                  }
                }
              ]
            }
          }
        }
      },
      answers: {
        select: {
          id: true,
          text: true,
          picture: {
            select: {
              url: true,
              private: true
            }
          },
          review: {
            select: {
              score: true,
              review: true,
              reviewer: {
                select: {
                  name: true
                }
              },
              updatedAt: true
            }
          },
          member: {
            select: {
              name: true
            }
          },
          final: true,
          createdAt: true,
          updatedAt: true
        },
        where: {
          team: {
            OR: [
              {
                ownerId: userId
              },
              {
                members: {
                  some: {
                    memberId: userId
                  }
                }
              }
            ]
          }
        }
      }
    }
  });

  if (!_quest) {
    throw createError({ status: 404, statusText: 'Not found!' });
  }

  if (!_quest.hunt.revealQuests) {
    throw createError({ status: 404, statusText: 'Not found!' });
  }

  const teamId = _quest.hunt.teams[0]?.id ?? null;
  // @ts-expect-error undefined to remove from DTO
  _quest.hunt.teams = undefined;

  const { answers, ...quest } = _quest;

  const answer = answers.length > 0 ? answers[0] : null;

  return { answer, ...quest, teamId };
});