import { protectedProcedure } from '../../procedure';
import { router } from '../../trpc';
import { EltInputSchema, EltOutputSchema } from './types';
import { getEltKasko } from '@/api/elt/query';
import initializeApollo from '@/apollo/client';
import eltHelper from '@/process/elt/lib/helper';
import { makeEltKaskoRequest } from '@/process/elt/lib/request';
import { convertEltKaskoResponse } from '@/process/elt/lib/response';
import RootStore from '@/stores/root';
import { createTRPCError } from '@/utils/trpc';

export const eltKaskoRouter = router({
  eltKasko: protectedProcedure
    .input(EltInputSchema)
    .output(EltOutputSchema)
    .mutation(async ({ input, ctx }) => {
      try {
        const apolloClient = initializeApollo(null, ctx.headers);
        const store = new RootStore();
        store.$calculation.$values.hydrate(input.calculation.values);

        const context = { apolloClient, store };
        const { init: initElt } = await eltHelper(context);
        const { kasko: initRows } = await initElt();

        const requests = initRows.map((row) =>
          makeEltKaskoRequest(context, row)
            .then((request) => getEltKasko(request))
            .then((response) => convertEltKaskoResponse({ context, response, row }))
            .then((convertedRow) => convertedRow)
            .catch((error) => ({
              ...row,
              message: error.message,
              status: 'error',
            }))
        );

        return {
          rows: await Promise.all(requests),
        };
      } catch (error) {
        throw createTRPCError(error);
      }
    }),
});