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 User from "../../models/users.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) {
    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";
    console.log(rawQuery1);
    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 GetGroupDetails(data) {
  try {
    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 }
          }]
        },
        {
          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']],
            }
          ]
        }]
    })
    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)
  }
}

// get People list of user networks
/*export async function getPeopleList(data) {
  try {
    let groupIds = [];
    let groupData = await GroupMemberDB.findAll({
      where: {
        user_id: data.user_id
      },
    })
    for (let i = 0; i < groupData.length; i++) {
      groupIds.push(groupData[i].group_id)
    }
    let userDetails = await GroupMemberDB.paginate({
      paginate: 10,
      page: data.page,
      where: {
        group_id: {
          [Op.in]: groupIds
        },
        user_id: {
          [Op.ne]: data.user_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 },
        order: [['name', "ASC"]],
      }],
      group: 'user_id'
    })
    return userDetails;
  } catch (error) {
    console.log(error);
    throw new Error(error);
  }
}*/

//above function New code 
/*export async function getPeopleList(data) {
  try {
    let groupIds = [];
    const groupData = await User.findAll();
    if(groupData.length === 0){
      return [];
    }
    //console.log(data.user_id,groupData);
    for (let i = 0; i < groupData.length; i++) {
      groupIds.push(groupData[i].group_id)
    }
    let userDetails = await User.paginate({
      paginate: 10,
      page: data.page,
    })
    return userDetails;
  } catch (error) {
    console.log(error);
    throw new Error(error);
  }
} */
export async function getPeopleList(data) {
  try {
    let groupIds = [];
    let groupData = await GroupMemberDB.findAll({
      where: {
        user_id: data.user_id
      },
    });

    // Check if groupData is empty
    if (groupData.length === 0) {
      // If empty, fetch all users directly
      let userDetails = await GroupMemberDB.paginate({
        paginate: 10,
        page: data.page,
        where: {
          user_id: {
            [Op.ne]: data.user_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 },
          order: [['name', "ASC"]],
        }]
      });
      return userDetails;
    }

    // If groupData is not empty
    for (let i = 0; i < groupData.length; i++) {
      groupIds.push(groupData[i].group_id)
    }

    let userDetails = await GroupMemberDB.paginate({
      paginate: 10,
      page: data.page,
      where: {
        group_id: {
          [Op.in]: groupIds
        },
        user_id: {
          [Op.ne]: data.user_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 },
        order: [['name', "ASC"]],
      }],
      group: ['user_id', 'group_members.id'] // Ensure all non-aggregated columns are included in the GROUP BY clause
    });
    return userDetails;
  } catch (error) {
    console.log(error);
    throw new Error(error);
  }
}



// search user of particular user network
export async function searchPeopleList(data) {
  try {
    let groupIds = [];
    let groupData = await GroupMemberDB.findAll({
      where: {
        user_id: data.user_id
      },
    })
    for (let i = 0; i < groupData.length; i++) {
      groupIds.push(groupData[i].group_id)
    }
    let userDetails = await GroupMemberDB.paginate({
      paginate: 10,
      page: data.page,
      where: {
        group_id: {
          [Op.in]: groupIds
        },
        user_id: {
          [Op.ne]: data.user_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,
          name: {
            [Op.like]: `%${data.user_name}%`
          }
        },
        order: [['name', "ASC"]],
      }],
      group: 'user_id'
    })
    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 }
      }],
    })
    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`.`created_by`, `groups`.`group_name`, `groups`.`group_profile`, `groups`.`group_code`, `groups`.`created_at`, MAX(`group_members`.`user_id`) AS `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 `groups`.`id` ORDER BY `groups`.`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
        }],
      })
      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) {
    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);
  }
}