import { router } from '../../trpc';
import { createRequestData } from './lib/request';
import { transformCalculateResults } from './lib/transform';
import { validate } from './lib/validation';
import { CalculateInputSchema, CalculateOutputSchema } from './types';
import { calculate } from '@/api/core/query';
import type { User } from '@/api/user/types';
import initializeApollo from '@/apollo/client';
import { protectedProcedure } from '@/server/procedure';
import { HttpError } from '@/utils/error';
import { createTRPCError } from '@/utils/trpc';
import { QueryClient } from '@tanstack/react-query';

export const calculateRouter = router({
  calculate: protectedProcedure
    .input(CalculateInputSchema)
    .output(CalculateOutputSchema)
    .mutation(async ({ input, ctx }) => {
      const apolloClient = initializeApollo(null, ctx.headers);
      const queryClient = new QueryClient();

      try {
        if (!ctx.unlimited) {
          const validationResult = await validate({
            context: {
              apolloClient,
              queryClient,
              user: ctx.user,
            },
            input,
          });

          if (validationResult.success === false) {
            throw new HttpError(validationResult.message, 400);
          }
        }

        let user: Pick<User, 'domainName'> = { domainName: ctx.user.domainName };
        if (ctx.unlimited && input.values.user) {
          user = { domainName: input.values.user };
        }

        const requestData = await createRequestData({
          context: {
            apolloClient,
            queryClient,
            ...ctx,
            user,
          },
          input,
        });

        const calculateResult = await calculate(requestData);

        const result = transformCalculateResults({
          calculateInput: input,
          requestCalculate: requestData,
          responseCalculate: calculateResult,
        });

        // TEMP
        if (ctx.unlimited) {
          result.__calculateResult = calculateResult;
        }

        return {
          data: result,
          success: true,
        };
      } catch (error) {
        throw createTRPCError(error);
      }
    }),
});