import sequelize from "../../config/database.config.js";
import Groups from "../../models/groups.model.js";
import moment from "moment";
import * as helper from "../../helper/index.js";
import GroupMemberDB from "../../models/group_members.model.js";
import GroupCafeDB from "../../models/group_cafes.model.js";
import CafeDB from "../../models/cafes.model.js";
import User from "../../models/users.model.js";
import CafeTimingDB from "../../models/cafe_timings.model.js";
import { Op } from "sequelize";
import CafeManagementDB from "../../models/CafeManagement.model.js";

// create Group
export async function createGroup(groupData) {
  try {
    let storeGroupMemberObj = [];
    let storeGroupCafeObj = [];
    let result = await Groups.create({
      group_name: groupData.group_name,
      created_by: groupData.user_id,
      group_code: Math.floor(100000 + Math.random() * 900000),
      group_profile: groupData.group_profile,
      is_active: 1,
      created_at: moment().unix(),
    });

    if ("group_members" in groupData) {
      if (groupData.group_members.length > 0) {
        groupData.group_members.forEach((element) => {
          storeGroupMemberObj.push({
            group_id: result.id,
            user_id: element.user_id,
            created_at: moment().unix(),
          });
        });
      }
    }
    storeGroupMemberObj.push({
      group_id: result.id,
      user_id: groupData.user_id,
      created_at: moment().unix(),
    });
    await GroupMemberDB.bulkCreate(storeGroupMemberObj);
    groupData.group_cafes.forEach((element) => {
      storeGroupCafeObj.push({
        group_id: result.id,
        cafe_id: element.cafe_id,
        created_at: moment().unix(),
      });
    });
    await GroupCafeDB.bulkCreate(storeGroupCafeObj);
    return result;
  } catch (error) {
    console.log(error);
    throw new Error(error);
  }
}

//get cafe list by group id and edit time
export async function getCafeList(data) {
  try {
    let groupDetails = await CafeDB.paginate({
      paginate: 10,
      page: data.page,
      attributes: [
        "id",
        "cafe_name",
        "banner_image",
        "address",
        "latitude",
        "longitude",
        [
          sequelize.literal(
            `round(${helper.haversine(data.latitude, data.longitude)})`
          ),
          "distance",
        ],
      ],
      where: {
        is_active: 1,
        signup_completed: 1,
        profile_completed: 1,
        menu_completed: 1,
        deleted_at: 0,
        is_admin_approved: 1,
      },
      include: [
        {
          model: GroupCafeDB,
          as: "group_cafes",
          attributes: ["id", "cafe_id", "group_id"],
          required: false,
          where: {
            group_id: data.group_id,
          },
        },
      ],
    });

    return groupDetails;
  } catch (error) {
    throw new Error(error);
  }
}

//get all cafe list in create group
export async function getAllCafe(data) {
  try {
    let cafe_details = await CafeDB.paginate({
      page: parseInt(data.page),
      paginate: 10,
      where: {
        is_active: 1,
        signup_completed: 1,
        profile_completed: 1,
        menu_completed: 1,
        deleted_at: 0,
        is_admin_approved: 1,
      },
      attributes: [
        "id",
        "cafe_name",
        "banner_image",
        "latitude",
        "longitude",
        "address",
        [
          sequelize.fn(
            "ROUND",
            sequelize.literal(
              `3958.8 * acos(cos(radians(${data.latitude})) * cos(radians(latitude)) * cos(radians(${data.longitude}) - radians(longitude)) + sin(radians(${data.latitude})) * sin(radians(latitude)))`
            ),
            2
          ),
          "distance",
        ],
      ],
      order: [[sequelize.col("distance"), "ASC"]],
    });
    return cafe_details;
  } catch (error) {
    throw new Error(error);
  }
}

//get group details by id
export async function GetGroupDetails(data) {
  try {
    let todayDayId = new Date().getDay();
    let currentTime = moment().format("HH:mm");
    const haversine = `(
      3959 * acos(
          cos(radians(${data.latitude}))
          * cos(radians(latitude))
          * cos(radians(longitude) - radians(${data.longitude}))
          + sin(radians(${data.latitude})) * sin(radians(latitude))
      )
    )`;
    let groupDetails = await Groups.findOne({
      where: { id: data.group_id },
      attributes: [
        "id",
        "group_name",
        "created_by",
        "group_code",
        "group_profile",
        "created_at",
      ],
      include: [
        {
          model: GroupMemberDB,
          as: "group_details",
          attributes: ["id", "user_id"],
          include: [
            {
              model: User,
              as: "user_data",
              attributes: ["id", "name", "email", "profile_picture"],
              where: { is_deleted: 0, is_active: 1, is_verified: 1, type: 1 },
            },
          ],
        },
        {
          model: GroupCafeDB,
          as: "group_cafe",
          include: [
            {
              model: CafeDB,
              as: "cafe_data",
              required: true,
              attributes: [
                "id",
                "cafe_name",
                "banner_image",
                "address",
                "latitude",
                "longitude",
                [sequelize.literal(`round(${haversine})`), "distance"],
              ],
              order: [[sequelize.col("distance"), "ASC"]],
              include: [
                {
                  model: CafeTimingDB,
                  as: "time_sheet_data",
                  required: false,
                  where: {
                    day: todayDayId,
                    open_time: {
                      [Op.lte]: currentTime,
                    },
                    close_time: {
                      [Op.gte]: currentTime,
                    },
                  },
                },
                {
                  model: CafeManagementDB,
                  attributes: ["id", "cafe_id", "click_and_collect"],
                  required: false,
                },
              ],
            },
          ],
        },
      ],
    });
    groupDetails = JSON.stringify(groupDetails);
    groupDetails = JSON.parse(groupDetails);
    for (let index = 0; index < groupDetails.group_details.length; index++) {
      const element = groupDetails.group_details[index];
      element.user_data.is_admin = 0;
      if (parseInt(element.user_id) == parseInt(groupDetails.created_by)) {
        element.user_data.is_admin = 1;
      }
    }
    for (let i = 0; i < groupDetails.group_cafe.length; i++) {
      const cafe = groupDetails.group_cafe[i];
      cafe.cafe_data.is_open =
        cafe.cafe_data.time_sheet_data.length > 0 ? 1 : 0;
    }

    // groupDetails['admin'] = created_by_data
    return groupDetails;
  } catch (error) {
    throw new Error(error);
  }
}

//if groupData empty then show all users (above function new code)
export async function getPeopleList(data) {
  try {
    const result = await User.paginate({
      paginate: 10,
      page: data.page,
      where: {
        is_deleted: 0,
        is_active: 1,
        is_verified: 1,
        type: 1,
        id: {
          [Op.ne]: data.user_id,
        },
      },
      attributes: ["id", "name", "email", "profile_picture"],
      order: [["name", "ASC"]],
    });

    return result;
  } catch (error) {
    throw new Error(error);
  }
}

//Above function recoded to search in users'list
export async function searchPeopleList(data) {
  try {
    let whereCondition = {
      id: {
        [Op.ne]: data.user_id,
      },
      is_deleted: 0,
      is_active: 1,
      is_verified: 1,
      type: 1,
      name: {
        [Op.like]: `%${data.user_name}%`,
      },
    };

    let userDetails = await User.paginate({
      paginate: 10,
      page: data.page,
      where: whereCondition,
      attributes: ["id", "name", "email", "profile_picture"],
      order: [["name", "ASC"]],
    });

    return userDetails;
  } catch (error) {
    throw new Error(error);
  }
}

//get all user list in group wise
export async function getGroupPeopleList(data, user_id) {
  try {
    let groupDetails = await GroupMemberDB.paginate({
      paginate: 10,
      page: data.page,
      where: { group_id: data.group_id },
      attributes: ["id", "group_id", "user_id"],
      include: [
        {
          model: User,
          as: "user_data",
          attributes: ["id", "name", "email", "profile_picture"],
          where: { is_deleted: 0, is_active: 1, is_verified: 1, type: 1 },
        },
      ],
    });
    groupDetails = JSON.stringify(groupDetails);
    groupDetails = JSON.parse(groupDetails);
    for (let index = 0; index < groupDetails.docs.length; index++) {
      groupDetails.docs[index].is_admin = 0;
      try {
        let isAdmin = await Groups.findOne({
          where: {
            id: groupDetails.docs[index].group_id,
            created_by: groupDetails.docs[index].user_id,
          },
        });
        if (isAdmin && isAdmin.created_by == groupDetails.docs[index].user_id) {
          groupDetails.docs[index].is_admin = 1;
        }
      } catch (error) {
        throw new Error(error);
      }
    }
    return groupDetails;
  } catch (error) {
    throw new Error(error);
  }
}

// add additional cafes in group
export async function addCafe(data) {
  try {
    await GroupCafeDB.destroy({
      where: { group_id: data.group_id },
    });
    let storeGroupCafeObj = [];
    data.group_cafes.forEach((element) => {
      storeGroupCafeObj.push({
        group_id: data.group_id,
        cafe_id: element.cafe_id,
        created_at: moment().unix(),
      });
    });
    await GroupCafeDB.bulkCreate(storeGroupCafeObj);
  } catch (error) {
    throw new Error(error);
  }
}

export async function getGroupData(group_id) {
  try {
    const result = await Groups.findByPk(group_id);
    if (result) {
      const groupMembers = await GroupMemberDB.findAll({
        where: {
          group_id: result.dataValues.id,
        },
        attributes: ["id", "user_id"],
        include: [
          {
            model: User,
            as: "user_data",
            attributes: [["id", "user_id"], "name", "profile_picture"],
            where: {
              is_deleted: 0,
              is_active: 1,
              is_verified: 1,
              type: 1,
            },
            required: true,
          },
        ],
      });
      const groupDetails = result.dataValues;
      groupDetails.group_members = groupMembers;
      return groupDetails;
    } else {
      throw new Error("Requested group not found!");
    }
  } catch (error) {
    throw new Error(error);
  }
}

//get group list
export async function getGroupList(userId, page) {
  try {
    if (parseInt(page) > 0) page = parseInt(page) - 1;
    page = parseInt(page) * 10;
    const rawQuery =
      "SELECT `groups`.`id`, `groups`.`created_by`,  `groups`.`group_name`, `groups`.`group_profile`,`groups`.`group_code`,`groups`.`created_at`, `group_members`.`user_id` FROM `groups` INNER JOIN `group_members` ON `groups`.`id` = `group_members`.`group_id` WHERE (`groups`.`created_by` = :created_by OR `group_members`.`user_id` = :user_id) AND `groups`.`is_active` = 1 GROUP BY `id` ORDER BY `id` DESC LIMIT :offset, :limit;";
    const replacements = {
      created_by: parseInt(userId),
      user_id: parseInt(userId),
      offset: parseInt(page),
      limit: 10,
    };
    let group_data = await sequelize.query(rawQuery, {
      replacements,
      type: sequelize.QueryTypes.SELECT,
    });
    group_data = JSON.stringify(group_data);
    group_data = JSON.parse(group_data);
    for (let index = 0; index < group_data.length; index++) {
      const element = group_data[index];
      element.group_members = await GroupMemberDB.findAll({
        where: {
          group_id: element.id,
        },
        attributes: ["id", "user_id"],
        include: [
          {
            model: User,
            as: "user_data",
            attributes: [["id", "user_id"], "name", "profile_picture"],
            where: {
              is_deleted: 0,
              is_active: 1,
              is_verified: 1,
              type: 1,
            },
            required: true,
          },
        ],
      });
      element.group_members = JSON.stringify(element.group_members);
      element.group_members = JSON.parse(element.group_members);
      for (let i = 0; i < element.group_members.length; i++) {
        const element1 = element.group_members[i];
        element1.user_data.is_admin = 0;
        if (element1.user_id == element.created_by) {
          element1.user_data.is_admin = 1;
        }
      }
    }
    return group_data;
  } catch (error) {
    console.log(error);
    throw new Error(error);
  }
}

//remove user from group
export async function removeUser(data) {
  try {
    await GroupMemberDB.destroy({
      where: { group_id: data.group_id, user_id: data.user_id },
    });
  } catch (error) {
    throw new Error(error);
  }
}

//exit group
export async function exitGroup(data) {
  try {
    let getGroupDetails = await Groups.findOne({
      where: { id: data.group_id },
      attributes: ["created_by"],
    });
    if (getGroupDetails && getGroupDetails.created_by == data.user_id) {
      await Groups.destroy({
        where: { id: data.group_id },
      });
    } else {
      await GroupMemberDB.destroy({
        where: { group_id: data.group_id, user_id: data.user_id },
      });
    }
    return getGroupDetails;
  } catch (error) {
    throw new Error(error);
  }
}

// get Group Code
export async function findcode(groupcode) {
  try {
    let result = await Groups.findOne({
      where: {
        group_code: groupcode,
      },
    });
    return result;
  } catch (error) {
    throw new Error(error);
  }
}

// create group id
export async function createMember(data) {
  try {
    await GroupMemberDB.create(data);
    return true;
  } catch (error) {
    throw new Error(error);
  }
}

//get Group Member
export async function getMemberDetail(user_id, data) {
  try {
    let get_id = await GroupMemberDB.findOne({
      where: {
        group_id: data,
        user_id: user_id,
      },
    });
    return get_id;
  } catch (error) {
    throw new Error(error);
  }
}

export async function findId(user_id, group_id) {
  try {
    let CreatedId = await Groups.findOne({
      where: {
        created_by: user_id,
        id: group_id,
      },
    });
    return CreatedId;
  } catch (error) {
    throw new Error(error);
  }
}

// add members in group
export async function addMemberInGroup(data) {
  try {
    await GroupMemberDB.destroy({
      where: {
        group_id: parseInt(data.group_id),
      },
    });
    data.members.forEach(async (element) => {
      const [user, created] = await GroupMemberDB.findOrCreate({
        where: { group_id: data.group_id, user_id: element.user_id },
      });
    });
    return true;
  } catch (error) {
    throw new Error(error);
  }
}

// remove cafe from group
export async function removeCafeFromGroup(data) {
  try {
    await GroupCafeDB.destroy({
      where: {
        id: parseInt(data.id),
      },
    });
    return true;
  } catch (error) {
    throw new Error(error);
  }
}