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

// create Group
export async function createGroup(groupData) {
  try {
    let createGroupObj = {
      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(),
    };
    let result = await Groups.create(createGroupObj, {});
    let storeGroupMemberObj = [];
    groupData.group_members.forEach((element) => {
      storeGroupMemberObj.push({
        group_id: result.id,
        user_id: element.user_id,
        created_at: moment().unix(),
      });
    });
    await GroupMemberDB.bulkCreate(storeGroupMemberObj);
    let storeGroupCafeObj = [];
    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) {
    throw new Error(error);
  }
}

//get cafe list by group id and edit time
export async function getCafeList(data) {
  try {
    if (parseInt(data.page) > 0) data.page = parseInt(data.page) - 1;
    data.page = parseInt(data.page) * 10;
    const rawQuery =
      "SELECT `cafes`.`id`, `cafes`.`address`, `cafes`.`cafe_name`,`cafes`.`banner_image`,`cafes`.`address`,`cafes`.`latitude`,`cafes`.`longitude`, ROUND(3958.8 * ACOS(COS(RADIANS(:latitude)) * COS(RADIANS(`cafes`.`latitude`)) * COS(RADIANS(:longitude) - RADIANS(`cafes`.`longitude`)) + SIN(RADIANS(:latitude)) * SIN(RADIANS(`cafes`.`latitude`))),2) AS `distance`, CASE WHEN `group_cafes`.`cafe_id` IS NOT NULL THEN 1 ELSE 0 END AS `is_selected` FROM `cafes` LEFT OUTER JOIN `group_cafes` ON `cafes`.`id` = `group_cafes`.`cafe_id` AND `group_cafes`.`group_id` = :group_id WHERE `cafes`.`is_active` = 1 AND `cafes`.`signup_completed` = 1 AND `cafes`.`profile_completed` = 1 AND `cafes`.`menu_completed` = 1 AND `cafes`.`deleted_at` = 0 ORDER BY `is_selected` DESC,`distance` ASC LIMIT :offset, :limit";
    const replacements = {
      latitude: data.latitude,
      longitude: data.longitude,
      group_id: data.group_id,
      offset: parseInt(data.page),
      limit: 10,
    };
    const rawQuery1 =
      "SELECT `cafes`.`id`, `cafes`.`cafe_name`,`cafes`.`banner_image`,`cafes`.`address`,`cafes`.`latitude`,`cafes`.`longitude`, ROUND(3958.8 * ACOS(COS(RADIANS(:latitude)) * COS(RADIANS(`cafes`.`latitude`)) * COS(RADIANS(:longitude) - RADIANS(`cafes`.`longitude`)) + SIN(RADIANS(:latitude)) * SIN(RADIANS(`cafes`.`latitude`))),2) AS `distance`, CASE WHEN `group_cafes`.`cafe_id` IS NOT NULL THEN 1 ELSE 0 END AS `is_selected` FROM `cafes` LEFT OUTER JOIN `group_cafes` ON `cafes`.`id` = `group_cafes`.`cafe_id` AND `group_cafes`.`group_id` = :group_id WHERE `cafes`.`is_active` = 1 AND `cafes`.`signup_completed` = 1 AND `cafes`.`profile_completed` = 1 AND `cafes`.`menu_completed` = 1 AND `cafes`.`deleted_at` = 0 ORDER BY `is_selected` DESC,`distance` ASC";

    let cafe_details = await sequelize.query(rawQuery, {
      replacements,
      type: sequelize.QueryTypes.SELECT,
    });
    let totalCountDocs = await sequelize.query(rawQuery1, {
      replacements,
      type: sequelize.QueryTypes.SELECT,
    });
    let finalResult = {
      docs: cafe_details,
      page: Math.ceil(totalCountDocs.length / 10),
      total: totalCountDocs.length,
    };
    return finalResult;
  } 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 oldGetGroupDetails(data) {
  try {
    let loginUserDetails = await User.findOne({
      where: { id: data.user_id, is_active: 1, is_deleted: 0 },
      attributes: ["user_latitude", "user_longitude"],
    });
    let lat = parseFloat(loginUserDetails.user_latitude);
    let lng = parseFloat(loginUserDetails.user_longitude);

    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 }
          }]
        },
        {
          model: GroupCafeDB,
          as: 'group_cafe',
          include: [
            {
              model: CafeDB,
              as: 'cafe_data',
              required: true,
              attributes: ['id', 'cafe_name', 'banner_image', 'address', 'latitude', 'longitude',
                [
                  sequelize.fn(
                    'ROUND',
                    sequelize.literal(`3958.8 * acos(cos(radians(${lat})) * cos(radians(latitude)) * cos(radians(${lng}) - radians(longitude)) + sin(radians(${lat})) * sin(radians(latitude)))`),
                    2 // Number of decimal places to round off to
                  ),
                  'distance'
                ]],

              order: [[sequelize.col('distance'), 'ASC']],
            }
          ]
        }]
    })
    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
      }
    }
    // groupDetails['admin'] = created_by_data
    return groupDetails;
  } catch (error) {
    throw new Error(error)
  }
}

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)
  }
}

// get People list in edit group time and show by selected or not OR get selected user with new users list
export async function getPeopleList(data) {
  try {
    let user_details = await User.paginate({
      page: parseInt(data.page),
      paginate: 10,
      required: true,
      where: {
        id: {
          [Op.ne]: data.user_id,
        },
        is_active: 1,
        is_deleted: 0,
      },
      attributes: [
        "id",
        "name",
        "profile_picture",
        "user_latitude",
        "user_longitude",
        [
          sequelize.fn(
            "ROUND",
            sequelize.literal(
              `3958.8 * acos(cos(radians(${data.latitude})) * cos(radians(user_latitude)) * cos(radians(${data.longitude}) - radians(user_longitude)) + sin(radians(${data.latitude})) * sin(radians(user_latitude)))`
            ),
            2
          ),
          "distance",
        ],
      ],
      order: [[sequelize.col("distance"), "ASC"]],
      include: [
        {
          model: GroupMemberDB,
          where: { group_id: parseInt(data.group_id) },
          required: false,
        },
      ],
    });
    user_details = JSON.stringify(user_details);
    user_details = JSON.parse(user_details);
    for (let index = 0; index < user_details.docs.length; index++) {
      const element = user_details.docs[index];
      if (element.group_members[0] && element.group_members[0].id) {
        element.is_selected = 1;
      } else {
        element.is_selected = 0;
      }
      delete element.group_members
    }
    return user_details;
  } catch (error) {
    throw new Error(error);
  }
}

//get all user list in create group
export async function getAllUserList(data) {
  try {
    data.page = parseInt(data.page);
    const users = await User.paginate({
      where: {
        id: {
          [Op.ne]: data.user_id,
        },
        is_active: 1,
        is_deleted: 0,
      },
      paginate: 10,
      page: data.page,
      attributes: ["id", "name", "profile_picture"],
    });
    return users;
  } 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 }
      }],
    })
    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);
  }
}
//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`.`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
          },
          required: true
        }],

      })
    }
    return group_data;
  } catch (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 {
    (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 {
    let result = await GroupCafeDB.destroy({
      where: {
        id: parseInt(data.id)
      }
    })
    return true
  } catch (error) {
    throw new Error(error);
  }
}