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";

// 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
      },
      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,
      },
      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
                  },
                },
              }
              ]
            },
          ]
        }]
    })
    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);
  }
}