import { cache } from 'react';

import { AccountWithParams } from '@/packages/features/accounts/src/types/accounts';
import OpenAI from 'openai';

import PersonalCode from '~/lib/utils';

import { AnalysisTestResponse } from '../../(dashboard)/analysis-results/test/test-responses';
import { OrderAnalysisCard } from '../../_components/order-analyses-cards';

export const loadRecommendations = cache(recommendationsLoader);

type FormattedAnalysisResponse = {
  value: string;
  name: string;
  responseTime: string;
};

const getLatestResponseTime = (items: FormattedAnalysisResponse[]) => {
  if (!items?.length) return null;

  let latest = null;
  for (const it of items) {
    const d = new Date(it.responseTime);
    const t = d.getTime();
    if (!Number.isNaN(t) && (latest === null || t > latest.getTime())) {
      latest = d;
    }
  }
  return latest;
};

const getLatestUniqueAnalysResponses = (
  analysisResponses: AnalysisTestResponse[],
): { name: string; value: string; responseTime: string }[] => {
  const analysisElements = analysisResponses
    .map(({ orderedAnalysisElements }) => orderedAnalysisElements)
    .flat();

  console.log('analysisElements', analysisElements.length);

  const byName = analysisElements.reduce<
    Record<string, { name: string; value: string; responseTime: string }>
  >((acc, it) => {
    const responseTime = it?.results?.responseTime;
    const responseValue = it?.results?.responseValue;
    if (!responseTime || !responseValue) return acc;

    const key = it.analysisName;
    const cur = acc[key];
    const t = Date.parse(responseTime);
    const prevT = cur ? Date.parse(cur.responseTime) : -Infinity;

    if (!cur || t > prevT) {
      acc[key] = {
        name: key,
        value: responseValue.toString(),
        responseTime,
      };
    }
    return acc;
  }, {});

  return Object.values(byName);
};

async function recommendationsLoader(
  analysisResponses: AnalysisTestResponse[],
  analyses: OrderAnalysisCard[],
  account: AccountWithParams | null,
): Promise<any> {
  if (!process.env.OPENAI_API_KEY) {
    return [];
  }
  if (!account?.personal_code) {
    return [];
  }

  const client = new OpenAI();
  const { gender } = PersonalCode.parsePersonalCode(account.personal_code);
  console.log('analysisResponses', analysisResponses);
  console.log('analyises', analyses);
  const latestUniqueAnalysResponses =
    getLatestUniqueAnalysResponses(analysisResponses);
  // const latestResponseTime = getLatestResponseTime(latestUniqueAnalysResponses);
  // const latestISO = latestResponseTime
  //   ? new Date(latestResponseTime).toISOString()
  //   : 'none';
  // console.log('latestResponseTime', latestResponseTime);
  const formattedAnalysisResponses = latestUniqueAnalysResponses.map(
    ({ name, value }) => ({ name, value }),
  );
  const formattedAnalyses = analyses.map(({ description, title }) => ({
    description,
    title,
  }));

  console.log('formattedAnalyses', JSON.stringify(formattedAnalyses));
  console.log(
    'latestUniqueAnalysResponses',
    JSON.stringify(latestUniqueAnalysResponses),
  );

  const response = await client.responses.create({
    model: 'gpt-5-mini',
    store: false,
    prompt: {
      id: 'pmpt_68ca9c8bfa8c8193b27eadc6496c36440df449ece4f5a8dd',
      variables: {
        analyses: JSON.stringify(formattedAnalyses),
        results: JSON.stringify(formattedAnalysisResponses),
        gender: gender.value,
      },
    },
  });

  const json = JSON.parse(response.output_text);
  console.log('response.output_text', response.output_text);
  return json.recommended;
}