import axios from 'axios';
import SubCategory from '../../models/SubCategory.js';
import BadRequest from '../../helper/exception/badRequest.js';
import EventCount from '../../models/eventsCount.js';
import FormData from '../../models/formDataModel.js';
import NewQuestion from '../../models/newQuestions.js';
import NewSubQuestion from '../../models/newSubQuestions.js';
import TempFormData from '../../models/TempFormData.js';
import User from '../../models/User.js';
import Event from '../../models/Event.js';

export const getFormDataApi = async (queryData) => {
  const { subcategoryId, categoryId } = queryData;
  const whereClause = {};

  if (subcategoryId) whereClause.sub_category_id = subcategoryId;
  if (categoryId) whereClause.category_id = categoryId;

  // Fetch the main questions
  const questions = await NewQuestion.findAll({
    where: whereClause,
    include: [
      {
        model: SubCategory,
        as: 'subCategory',
        attributes: ['id', 'name'],
      },
      {
        model: NewSubQuestion,
        as: 'subQuestions', // This will fetch sub-questions for each main question
        separate: true,
        include: [
          {
            model: NewSubQuestion,
            as: 'parentQuestion', // Parent-child relationship
            attributes: ['id', 'question'],
          },
        ],
        order: [['order', 'ASC']],
      },
    ],
    order: [['createdAt', 'ASC']],
  });

  return questions;
};

export const postQuestions = async (data, user) => {
  let jsonData = { json_data: [] };

  const tempFormData = await TempFormData.findAll({
    where: { user_id: user },
    raw: true,
  });

  tempFormData.map((item) => {
    jsonData.json_data = [...jsonData.json_data, ...item.user_data.json_data];
    return null;
  });

  const uniqueResponsesMap = new Map(
    jsonData.json_data.map((response) => [response.questionId, response])
  );

  // Convert Map values back to array and filter the required fields
  const filteredResponses = Array.from(uniqueResponsesMap.values()).map(
    (value) => value
  );

  jsonData.json_data = filteredResponses;

  if (typeof jsonData === 'string') {
    jsonData = JSON.parse(jsonData);
    data = jsonData;
  } else {
    data = jsonData;
  }

  try {
    await Event.destroy({
      where: { user_id: user },
    });

    const EventCountData = await EventCount.findOne({
      where: { user_id: user },
      attributes: ['count', 'eventStatus'],
    });
    if (!EventCountData) {
      await EventCount.create({
        user_id: user,
        count: 0,
        eventStatus: 'pending',
      });
    } else {
      await EventCount.update(
        { count: 0, eventStatus: 'pending' },
        { where: { user_id: user } }
      );
    }

    await User.update(
      {
        eventStatus: 'pending',
      },
      { where: { id: user } }
    );

    const existingFormData = await FormData.findOne({
      where: { user_id: user },
      raw: true,
    });

    if (!existingFormData) {
      await FormData.create({
        user_id: user,
        userData: data,
      });
    }

    const response = await axios.post(
      'https://calendar-devapi.spericorn.com/api/json-response/',
      (data)
    );

    if (!response.data) {
      throw new Error('Empty response received');
    }

    const formDataPayload = {
      user_id: user,
      Data: response.data,
      userData: data,
    };

    const existingFormDataAgain = await FormData.findOne({
      where: { user_id: user },
      raw: true,
    });

    if (existingFormDataAgain) {
      await FormData.update(
        { Data: response.data },
        { where: { user_id: user } }
      );
    } else {
      await FormData.create(formDataPayload);
    }
    return JSON.stringify(data);
  } catch (err) {
    // await FormData.create({
    //   user_id: user,
    //   userData: data,
    // });
    await EventCount.update(
      { count: 0, eventStatus: 'active' },
      { where: { user_id: user } }
    );
    throw new BadRequest(err.response?.data?.Message || 'An error occurred');
  }
};

export const getDaysCountService = async (userId) => {
  const daysData = await EventCount.findOne({
    where: { user_id: userId },
    attributes: ['count', 'eventStatus'],
  });
  return daysData;
};

export const getUserFormDataService = async (
  userId,
  { categoryId, subcategoryId }
) => {
  if (!userId) {
    throw new BadRequest('User ID is required');
  }

  const formData = await FormData.findOne({
    where: { user_id: userId },
    attributes: ['user_id', 'userData'],
  });

  // if (!formData) {
    if (!categoryId) {
      throw new BadRequest('Category ID is required');
    }

    const tempFormData = await TempFormData.findOne({
      where: {
        user_id: userId,
        category_id: categoryId,
        sub_category_id: subcategoryId || null,
      },
      attributes: ['user_data'],
    });

    if (!tempFormData) {
      return [];
    }
    const data = { userData: tempFormData.user_data };
    return data;
  // }

  // return formData;
};

export const updateUserFormDataService = async (data, userId) => {
  let jsonData;
  const jsonDataString = data.json_data;

  if (typeof jsonDataString === 'string') {
    try {
      jsonData = JSON.parse(jsonDataString);
      data.json_data = jsonData;
    } catch (error) {
      throw new Error('Invalid JSON format in json_data');
    }
  } else {
    jsonData = jsonDataString;
    data.json_data = jsonData;
  }

  const formData = await FormData.findOne({
    where: { user_id: userId },
    attributes: ['user_id', 'userData'],
  });
  const EventCountData = await EventCount.findOne({
    where: { user_id: userId },
    attributes: ['count', 'eventStatus'],
  });
  if (!EventCountData) {
    await EventCount.create({
      user_id: userId,
      count: 0,
      eventStatus: 'pending',
    });
  } else {
    await EventCount.update(
      { count: 0, eventStatus: 'pending' },
      { where: { user_id: userId } }
    );
  }

  await User.update(
    {
      eventStatus: 'pending',
    },
    { where: { id: userId } }
  );

  if (formData) {
    await Event.destroy({
      where: { user_id: userId },
    });
  }

  if (!formData) {
    await FormData.create({
      user_id: userId,
      userData: data,
      status: 'pending',
    });
  }

  const response = await axios.post(
    'https://calendar-devapi.spericorn.com/api/json-response/',
    data
  );

  if (!response.data) {
    throw new Error('Empty response received');
  }

  await FormData.update(
    { Data: response.data, status: 'pending' },
    { where: { user_id: userId } }
  );
};

export const tempFormDataCreation = async (data, userId) => {
  const { categoryId, subcategoryId } = data;

  let jsonData;
  const jsonDataString = data.userData;

  if (typeof jsonDataString === 'string') {
    try {
      jsonData = JSON.parse(jsonDataString);
      data.userData = jsonData;
    } catch (error) {
      throw new Error('Invalid JSON format in json_data');
    }
  } else {
    jsonData = jsonDataString;
    data.userData = jsonData;
  }

  const existingTempFormData = await TempFormData.findOne({
    where: {
      user_id: userId,
      category_id: categoryId,
      sub_category_id: subcategoryId || null,
    },
  });

  if (!existingTempFormData) {
    await TempFormData.create({
      user_id: userId,
      category_id: categoryId,
      sub_category_id: subcategoryId || null,
      user_data: data.userData,
    });
  }

  if (existingTempFormData) {
    await TempFormData.update(
      { user_data: data.userData },
      {
        where: {
          user_id: userId,
          category_id: categoryId,
          sub_category_id: subcategoryId || null,
        },
      }
    );
  }
};