import { getToken } from "next-auth/jwt";
import { NextApiRequest, NextApiResponse } from 'next'
import { DayOfWeek, AvailabilityType } from '@prisma/client';
const common = require('../../src/helpers/common');
const data = require('../../src/helpers/data');
const subq = require('../../prisma/bl/subqueries');

import fs from 'fs';
import path from 'path';
import { all } from "axios";

/**
 * 
 * @param req import { NextApiRequest, NextApiResponse } from 'next'
 * @param res import { NextApiRequest, NextApiResponse } from 'next'
 */
export default async function handler(req, res) {
  const prisma = common.getPrismaClient();

  // Retrieve and validate the JWT token
  const token = await getToken({ req: req });
  if (!token) {
    // If no token or invalid token, return unauthorized status
    return res.status(401).json({ message: "Unauthorized to call this API endpoint" });
  }
  else {
    // If token is valid, log the user
    //console.log("JWT | User: " + token.email);
  }

  var action = req.query.action;
  var filter = req.query.filter;
  let day: Date;
  let isExactTime;
  if (req.query.date) {
    day = new Date(req.query.date);
    //date.setDate(date.getDate()); // Subtract one day to get the correct date, as calendar sends wrong date (one day ahead)
    //date.setHours(0, 0, 0, 0);
  }
  if (req.query.filterDate) {
    day = new Date(req.query.filterDate);
    isExactTime = true;
  }

  let monthInfo = common.getMonthDatesInfo(day);
  const searchText = req.query.searchText?.normalize('NFC');

  try {
    switch (action) {
      case "initDb":
        // Read the SQL script from the file
        const sqlFilePath = path.join(process.cwd(), 'prisma', 'data.sql');
        const sql = fs.readFileSync(sqlFilePath, 'utf8');

        // Execute the SQL script
        await prisma.$executeRawUnsafe(sql);
        res.status(200).json({ message: "SQL script executed successfully" });
        break;

      case "deleteAllPublishers":
        //get filter and delete all publishers containing that in first name or last name
        await prisma.publisher.deleteMany({
          where: {
            OR: [
              { firstName: { contains: filter } },
              { lastName: { contains: filter } },
            ],
          },
        });
        res.status(200).json({ "message": "ok" });
        break;
      case "deleteAllAvailabilities":
        //get filter and delete all publishers containing that in first name or last name
        await prisma.availability.deleteMany({
          where: filter ? {
            OR: [
              // { name: { contains: filter } },
              { starTime: { lte: day } }
            ]
          } : {}
        });
        res.status(200).json({ "message": "ok" });
        break;
      //gets publisher by names with availabilities and assignments 
      case "deleteAvailabilityForPublisher":
        let publisherId = req.query.publisherId;
        let dateFor;
        if (req.query.date) {
          dateFor = new Date(req.query.date);
          //get month info from date
          monthInfo = common.getMonthDatesInfo(dateFor);
        }
        const deleteFromPreviousAssignments = common.parseBool(req.query.deleteFromPreviousAssignments);
        // if datefor is not null/undefined, delete availabilities for that month
        try {
          await prisma.availability.deleteMany({
            where: {
              publisherId: publisherId,
              startTime: { gte: monthInfo?.firstMonday },
              endTime: { lte: monthInfo?.lastSunday }
            }
          });
          if (deleteFromPreviousAssignments) {
            await prisma.availability.deleteMany({
              where: {
                publisherId: publisherId,
                isFromPreviousAssignment: true
              }
            });
          }
          // await prisma.availability.deleteMany({
          //   where: {
          //     publisherId: publisherId
          //   }
          // });
          res.status(200).json({ "message": "ok" });
        } catch (error) {
          console.error("Error deleting availability for publisher: " + publisherId + " error: " + error);
          res.status(500).json({ error });
        }
        break;

      case "createAvailabilities": {
        const availabilities = req.body;
        //! console.log("createAvailabilities: " + JSON.stringify(availabilities));
        try {
          let createResults = await prisma.availability.createMany({
            data: availabilities
          });
          res.status(200).json({ "message": "ok", "results": createResults });
        } catch (error) {
          console.error("Error creating availabilities: " + error);
          res.status(500).json({ error });
        }
      }
        break;

      case "getCalendarEvents":
        let events = await getCalendarEvents(req.query.publisherId, day);
        res.status(200).json(events);

      case "getPublisherInfo":
        let pubs = await filterPublishers("id,firstName,lastName,email".split(","), "", null, req.query.assignments || true, req.query.availabilities || true, false, req.query.id);
        res.status(200).json(pubs[0]);
        break;
      case "getMonthlyStatistics":
        let allpubs = await getMonthlyStatistics("id,firstName,lastName,email", day);
        res.status(200).json(allpubs);
        break;

      case "getUnassignedPublishers":
        //let monthInfo = common.getMonthDatesInfo(date);
        let allPubs = await filterPublishers("id,firstName,lastName,email,isActive".split(","), "", day, true, true, false);
        let unassignedPubs = allPubs.filter(pub => pub.currentMonthAssignments == 0 && pub.availabilities.length > 0);
        res.status(200).json(unassignedPubs);
        break;
      case "filterPublishers":
        const fetchAssignments = common.parseBool(req.query.assignments);
        const fetchAvailabilities = common.parseBool(req.query.availabilities);
        let publishers = await filterPublishers(req.query.select, searchText, day, fetchAssignments, fetchAvailabilities);
        //!console.log("publishers: (" + publishers.length + ") " + JSON.stringify(publishers.map(pub => pub.firstName + " " + pub.lastName)));
        res.status(200).json(publishers);
        break;
      case "filterPublishersNew":
        let includeOldAvailabilities = common.parseBool(req.query.includeOldAvailabilities);
        let results = await filterPublishersNew_Available(req.query.select, day,
          common.parseBool(req.query.isExactTime), common.parseBool(req.query.isForTheMonth), includeOldAvailabilities);
        res.status(200).json(results);
        break;

      // find publisher by full name or email
      case "findPublisher":
        const getAll = common.parseBool(req.query.all) || false;
        let publisher = await data.findPublisher(filter, req.query.email, req.query.select, getAll);
        res.status(200).json(publisher);
        break;

      case "getShiftsForDay":

        // Setting the range for a day: starting from the beginning of the date and ending just before the next date.
        let startOfDay = new Date(day.getFullYear(), day.getMonth(), day.getDate());
        let endOfDay = new Date(day.getFullYear(), day.getMonth(), day.getDate(), 23, 59, 59, 999);

        const pubAvCount = await prisma.publisher.findMany({
          select: {
            id: true,
            firstName: true,
            lastName: true,
            _count: {
              select: {
                availabilities: true,
              }
            }
          }
        });

        let shiftsForDate = await prisma.shift.findMany({
          where: {
            startTime: {
              gte: startOfDay,
              lt: endOfDay
            },
          },
          include: {
            assignments: {
              include: {
                publisher: subq.publisherSelect
              },
            },
          },
        });

        shiftsForDate.forEach(shift => {
          shift.assignments.forEach(assignment => {
            assignment.publisher.availabilityCount = pubAvCount.find(pub => pub.id === assignment.publisher.id)?._count?.availabilities || 0;
          });
        }
        );

        console.log("shiftsForDate(" + day + ") - " + shiftsForDate.length + " : " + JSON.stringify(shiftsForDate.map(shift => shift.id)));

        res.status(200).json(shiftsForDate);
        break;

      case "copyOldAvailabilities":
        //get all publishers that don't have availabilities for the current month
        monthInfo = common.getMonthDatesInfo(day);
        // await prisma.availability.deleteMany({
        //   where: {
        //     startTime: {
        //       gte: monthInfo.firstMonday,
        //     },
        //     isFromPreviousMonth: true
        //   }
        // });
        let outdatedPubs = await prisma.publisher.findMany({
          where: {
            availabilities: {
              none: {
                startTime: {
                  gte: monthInfo.firstMonday,
                }
              }
            }
          },
          select: {
            id: true,
            firstName: true,
            lastName: true,
            availabilities: true
          }
        });
        outdatedPubs.forEach(async pub => {
          //  avail.startTime >= monthInfo.firstMonday
          //get prev month date:
          let prevMonth = new Date(monthInfo.firstMonday);
          prevMonth.setMonth(prevMonth.getMonth() - 1);
          let prevMonthInfo = common.getMonthDatesInfo(prevMonth);
          pub.availabilities = pub.availabilities.filter(avail => avail.startTime > prevMonthInfo.firstMonday);
          console.log("" + pub.firstName + " " + pub.lastName + " copying " + pub.availabilities.length + " availabilities from previous months.");
          pub.availabilities.forEach(async avail => {
            //get the new date based on the day of week and week of month
            if (!avail.weekOfMonth) {
              avail.weekOfMonth = common.getWeekOfMonth(avail.startTime)
            }
            let origMonthInfo = common.getMonthDatesInfo(avail.startTime);

            let newStart = common.getDateFromWeekNrAndDayOfWeek(monthInfo.firstMonday, avail.weekOfMonth, avail.dayofweek, avail.startTime);
            //ToDo: fix double check. also check if we're in 5th week and the month has 4 weeks
            // const availability = await data.findPublisherAvailability(publisher.id, newStart);
            // if (availability) {
            //   return;
            // }
            let newEnd = new Date(newStart.getTime());
            newEnd.setHours(avail.endTime.getHours(), avail.endTime.getMinutes(), 0, 0);
            let data = {
              publisherId: pub.id,
              dayOfMonth: null,
              dayofweek: avail.dayofweek || common.getDayOfWeekNameEnEnumForDate(avail.startTime),
              weekOfMonth: avail.weekofMonth || common.getWeekOfMonth(avail.startTime),
              // null for auto generated availabilities
              //dateOfEntry: new Date(), //avail.dateOfEntry || avail.startTime,
              startTime: newStart,
              endTime: newEnd,
              type: AvailabilityType.Monthly,
              isFromPreviousMonth: true,
              name: avail.name || "старо предпочитание",
              parentAvailabilityId: avail.id,
              // parentAvailability: {
              //   connect: {
              //     id: avail.id
              //   }
              // },
            }
            await prisma.availability.create({ data: data });

            //if month has 5 weeks and the monthInfo has 4 weeks copy the availabilities also from the 1st week to the 5th week
            if (monthInfo.nrOfWeeks == 5 && avail.weekOfMonth == 1 && origMonthInfo.nrOfWeeks == 4) {
              newStart = common.getDateFromWeekNrAndDayOfWeek(monthInfo.firstMonday, 5, avail.dayofweek, avail.startTime);
              newEnd = new Date(newStart.getTime());
              newEnd.setHours(avail.endTime.getHours(), avail.endTime.getMinutes(), 0, 0);
              data.weekOfMonth = 5;
              data.startTime = newStart;
              data.endTime = newEnd;
              await prisma.availability.create({ data: data });
            }

          });
        });

        //convert old assignments to availabilities

        res.status(200).json({ "message": "ok" });
        break;
      case "deleteCopiedAvailabilities":
        //delete all availabilities that are copied from previous months
        monthInfo = common.getMonthDatesInfo(day);
        await prisma.availability.deleteMany({
          where: {
            startTime: {
              gte: monthInfo.firstMonday,
            },
            isFromPreviousMonth: true
          }
        });

      case "replaceInAssignment":
        const { oldPublisherId, newPublisherId, shiftId } = req.method === "POST" ? req.body : req.query;

        const result = await replaceInAssignment(oldPublisherId, newPublisherId, shiftId);
        res.status(200).json(result);
        break;

      case "updateShifts":
        //get all shifts for the month and publish them (we pass date )
        let isPublished = common.parseBool(req.query.isPublished);
        let updated = await prisma.shift.updateMany({
          where: {
            startTime: {
              gte: new Date(monthInfo.firstMonday.getFullYear(), monthInfo.firstMonday.getMonth(), 1),
              lt: new Date(monthInfo.lastSunday.getFullYear(), monthInfo.lastSunday.getMonth() + 1, 1),
            }
          },
          data: {
            isPublished: isPublished
          }
        });
        console.log("Updated shifts: " + updated.count);
        res.status(200).json({ "message": "ok" });

        break;
      case "getPossibleShiftPublisherEmails":
        const subscribedPublishers = await prisma.publisher.findMany({
          where: {
            isSubscribedToCoverMe: true
          },
          select: {
            id: true,
            firstName: true,
            lastName: true,
            email: true
          }
        }).then(pubs => {
          return pubs.map(pub => {
            return {
              id: pub.id,
              name: pub.firstName + " " + pub.lastName,
              email: pub.email
            }
          });
        });

        let shift = await prisma.shift.findUnique({
          where: {
            id: parseInt(req.query.shiftId)
          }
        });
        let availablePublishers = await filterPublishersNew_Available("id,firstName,lastName,email", new Date(shift.startTime), true, false);
        //return names and email info only
        availablePublishers = availablePublishers.map(pub => {
          return {
            id: pub.id,
            name: pub.firstName + " " + pub.lastName,
            email: pub.email
          }
        });
        res.status(200).json({ shift, availablePublishers: availablePublishers, subscribedPublishers });
        break;

      default:
        res.status(200).json({
          "message": "no action '" + action + "' found"
        });
        break;
    }
  } catch (error) {
    console.error("API: Error executing action: " + action + " with filter: " + filter + " error: " + error);
    res.status(500).json({ error });
  }
}



export async function getMonthlyStatistics(selectFields, filterDate) {

  let publishers = [];
  selectFields = selectFields?.split(",");
  let selectBase = selectFields.reduce((acc, curr) => {
    acc[curr] = true;
    return acc;
  }, {});
  selectBase.assignments = {
    select: {
      id: true,
      shift: {
        select: {
          id: true,
          startTime: true,
          endTime: true
        }
      }
    }
  };
  let currentWeekStart: Date, currentWeekEnd: Date,
    currentMonthStart: Date, currentMonthEnd: Date,
    previousMonthStart: Date, previousMonthEnd: Date;


  let date = new Date(filterDate);
  date.setDate(filterDate.getDate());
  currentWeekStart = common.getStartOfWeek(date);
  currentWeekEnd = common.getEndOfWeek(date);

  var monthInfo = common.getMonthDatesInfo(date);
  currentMonthStart = monthInfo.firstMonday;
  currentMonthEnd = monthInfo.lastSunday;
  date.setMonth(date.getMonth() - 1);
  monthInfo = common.getMonthDatesInfo(date);
  previousMonthStart = monthInfo.firstMonday;
  previousMonthEnd = monthInfo.lastSunday;


  const prisma = common.getPrismaClient();
  publishers = await prisma.publisher.findMany({
    select: {
      ...selectBase,
    }
  });

  publishers.forEach(pub => {
    // Debug logs to help identify issues
    pub.currentWeekAssignments = pub.assignments.filter(assignment => {
      return assignment.shift.startTime >= currentWeekStart && assignment.shift.startTime <= currentWeekEnd;
    }).length;
    pub.currentMonthAssignments = pub.assignments.filter(assignment => {
      return assignment.shift.startTime >= currentMonthStart && assignment.shift.startTime <= currentMonthEnd;
    }).length;
    pub.previousMonthAssignments = pub.assignments.filter(assignment => {
      return assignment.shift.startTime >= previousMonthStart && assignment.shift.startTime <= previousMonthEnd;
    }).length;
  });
  return publishers;
}


export async function filterPublishersNew_Available(selectFields, filterDate, isExactTime = false, isForTheMonth = false, isWithStats = true, includeOldAvailabilities = false) {
  return data.filterPublishersNew(selectFields, filterDate, isExactTime, isForTheMonth, isWithStats, includeOldAvailabilities);
}

// availabilites filter:
// 1. if dayOfMonth is null, match by day of week (enum)
// 2. if dayOfMonth is not null, match by date
// 3. if date is 00:00:00, match by date only (without time)
// 4. if date is not 00:00:00, it should be in the range of start and end times
// this way we distinguish between weekly availabiillities (entered without dayOfMonth) and old availabilities from previous months (entered with dayOfMonth, but we set it to null),
// (To validate) we use useDateFilter in combination with the filterDate to get publishers without availabilities for the day:
// 1: useDateFilter = false, filterDate = null - get all publishers with availabilities for the current month
// 2: useDateFilter = false, filterDate = date - get all publishers with availabilities for the current month
// 3: useDateFilter = true, filterDate = null - get all publishers with availabilities for the current month
// 4: useDateFilter = true, filterDate = date - get all publishers with availabilities for the current month and filter by date

export async function filterPublishers(selectFields, searchText, filterDate, fetchAssignments: boolean = true, fetchAvailabilities: boolean = true, useDateFilter = true, id = null) {

  let currentWeekStart: Date, currentWeekEnd: Date,
    currentMonthStart: Date, currentMonthEnd: Date,
    previousMonthStart: Date, previousMonthEnd: Date,
    filterDateEnd: Date,
    publishers = [];

  if (!filterDate) {
    useDateFilter = false;
    previousMonthStart = new Date();
    previousMonthStart.setDate(1);
    previousMonthStart.setMonth(previousMonthStart.getMonth() - 1);
  }
  else {

    let date = new Date(filterDate.getTime());
    //date.setDate(filterDate.getDate());
    currentWeekStart = common.getStartOfWeek(date);
    currentWeekEnd = common.getEndOfWeek(date);

    var monthInfo = common.getMonthDatesInfo(date);
    currentMonthStart = monthInfo.firstMonday;
    currentMonthEnd = monthInfo.lastSunday;
    date.setMonth(date.getMonth() - 1);
    monthInfo = common.getMonthDatesInfo(date);
    previousMonthStart = monthInfo.firstMonday;
    previousMonthEnd = monthInfo.lastSunday;

    filterDateEnd = new Date(filterDate);
    filterDateEnd.setHours(23, 59, 59, 999);
  }


  let whereClause = {};
  if (id) {
    whereClause = {
      id: String(id)
    }
  }
  const searchTextString = String(searchText || "").trim();
  if (searchTextString !== "") {
    whereClause = {
      OR: [
        { firstName: { contains: searchTextString } },
        { lastName: { contains: searchTextString } },
      ],
    };
  }

  // Base select fields

  // Only attempt to split if selectFields is a string; otherwise, use it as it is.
  selectFields = typeof selectFields === 'string' ? selectFields.split(",") : selectFields;

  let selectBase = selectFields.reduce((acc, curr) => {
    acc[curr] = true;
    return acc;
  }, {});


  // If assignments flag is true, fetch assignments
  if (fetchAssignments) {

    //!! WORKING CODE, but heavy on the DB !!
    selectBase.assignments = {
      select: {
        id: true,
        shift: {
          select: {
            id: true,
            startTime: true,
            endTime: true
          }
        }
      },
      where: {
        shift: {
          OR: [
            // {
            //   startTime: {
            //     gte: currentWeekStart,
            //     lte: currentWeekEnd
            //   }
            // },
            // {
            //   startTime: {
            //     gte: currentMonthStart,
            //     lte: currentMonthEnd
            //   }
            // },
            {
              startTime: {
                gte: previousMonthStart,
                // lte: previousMonthEnd
              }
            },

          ]
        }
      }
    };
    //selectBase.assignments = true;
  }

  let dayOfWeekEnum: DayOfWeek
  if (filterDate) {
    // Determine day of week using common function
    dayOfWeekEnum = common.getDayOfWeekNameEnEnumForDate(filterDate);
    if (filterDate.getHours() > 21 || filterDate.getHours() < 6) {
      filterDate.setHours(0, 0, 0, 0); // Set to midnight
    }
  }
  // console.log(`filterDate: ${filterDate}`);
  // console.log(`filterDateEnd: ${filterDateEnd}`);


  if (filterDate && useDateFilter) {
    // Info, description and ToDo:
    // We should distinguish between availabilities with dayOfMonth and without
    // If dayOfMonth is null, we should match by day of week using the enum
    // If dayOfMonth is not null, we should match by date.
    // if date is 00:00:00, we should match by date only (without time)
    // if date is not 00:00:00, it should be in the range of start and end times
    // we should also include availabilities from previous assignments but not with preference - dayOfMonth is null. we shuold include them only if they match the day of week
    // and distinguish between weekly availabiillities (entered without dayOfMonth) and old availabilities from previous months (entered with dayOfMonth, but we set it to null),
    // which we count as weekly availabilities. We can use the type field for that
    //console.log(`filterDate: ${filterDate}. date: ${filterDate.getDate()}. dayOfWeekEnum: ${dayOfWeekEnum}. useDateFilter: ${useDateFilter}`);

    // we will have 3 cases: up-to date availabilities, old availabilities from previous months and availabilities from previous assignments but not with preference
    // we will use the type field to distinguish between them
    // up-to date availabilities will have type = 1
    // old availabilities from previous months will have type = 2 - we want to drop that function to simplify the code and avoid confusion
    // availabilities from previous assignments but not with preference will have type = 3
    // also, permanent weekly availabilities will have dayOfMonth = null and type = 0
    // for 0 we will match by dayOfWeekEnum and times
    // for 1 we will match by exact date and times
    // for 2 we will match by dayofweek, weekOfMonth and times
    // for 3 we will match by dayofweek, weekOfMonth and times - this is the same as 2, but we will not count them as availabilities for the current month


    // generaion of schedule:
    /*
    option 1: fill from blank - first two places per shift, then more if possible
    option 2: fill from previous schedule , remove all assignments where new availabilities are not available 
    and permanent availabilities to make room for changes (we want to shuffle if possible??? do we?)
    continue with option 1 from there
    which one depends on if we prioritize empty shifts or making sure everyone has up to date availabilities
    */

    //substract the time difference between from ISO string and local time    
    const offset = filterDate.getTimezoneOffset() * 60000; // offset in milliseconds
    var dateAsISO = new Date(filterDate.getTime() + offset);
    //if full day, match by date only
    if (filterDate.getHours() == 0 || dateAsISO.getHours() == 0) {
      whereClause["availabilities"] = {
        some: {
          OR: [
            // Check only by date without considering time ( Assignments on specific days without time)
            {
              startTime: { gte: filterDate },
              endTime: { lte: filterDateEnd },
            }
            ,
            // Check if dayOfMonth is null and match by day of week using the enum (Assigments every week) 
            // This includes availabilities from previous assignments but not with preference 
            {
              dayOfMonth: null, // includes monthly and weekly repeats
              dayofweek: dayOfWeekEnum,
              // ToDo: and weekOfMonth
              startTime: { lte: filterDate },
              AND: [
                {
                  OR: [ // OR condition for repeatUntil to handle events that either end after filterDate or repeat forever
                    { endDate: { gte: filterDate } },
                    { endDate: null }
                  ]
                }
              ]
            }
          ]
        }
      };
    }
    //if not full day, match by date and time
    else {
      //match exact time (should be same as data.findPublisherAvailability())
      whereClause["availabilities"] = {
        some: {
          OR: [
            // Check if dayOfMonth is set and filterDate is between start and end dates (Assignments on specific days AND time)
            {
              dayOfMonth: filterDate.getDate(),
              startTime: { lte: filterDate },
              endTime: { gte: filterDate }
            },
            // Check if dayOfMonth is null and match by day of week using the enum (Assigments every week)
            {
              dayOfMonth: null,
              dayofweek: dayOfWeekEnum,
              startTime: { gte: filterDate },
            }
          ]
        }
      };
    }
  } else {
    // we use month filter if date is passed and useDateFilter is false to get all publishers with availabilities for the current month
    if (fetchAvailabilities) {
      // If no filter date, return all publishers's availabilities for currentMonthStart
      whereClause["availabilities"] = {
        some: {
          OR: [
            // Check if dayOfMonth is not null and startTime is after currentMonthStart (Assignments on specific days AND time)
            {
              dayOfMonth: { not: null },
              startTime: { gte: currentMonthStart },
              endTime: { lte: currentMonthEnd }
            },
            // Check if dayOfMonth is null and match by day of week using the enum (Assigments every week)
            {
              dayOfMonth: null,
            }
          ]
        }
      };
      //try here
      // selectBase.аvailabilities = {
      //   select: {
      //     dayofweek: true,
      //     dayOfMonth: true,
      //     startTime: true,
      //     endTime: true,
      //     weekOfMonth: true,
      //     type: true
      //   },
      //   where: {
      //     OR: [
      //       {
      //         startTime: { gte: currentMonthStart },
      //         endTime: { lte: currentMonthEnd }
      //       }
      //     ]
      //   }
      // }
    }
  }

  //include availabilities if flag is true
  const prisma = common.getPrismaClient(); //why we need to get it again?
  publishers = await prisma.publisher.findMany({
    where: whereClause,
    select: {
      ...selectBase,
      ...(fetchAvailabilities && { availabilities: true }),
      // ...(fetchAssignments && {
      //   assignments: {
      //     include: {
      //       shift: true,
      //     }
      //   }
      // }
      // )
    }
  });

  console.log(`publishers: ${publishers.length}, WhereClause: ${JSON.stringify(whereClause)}`);

  if (filterDate) {

    if (fetchAssignments) {
      //get if publisher has assignments for current weekday, week, current month, previous month
      publishers.forEach(pub => {
        // Filter assignments for current day
        pub.currentDayAssignments = pub.assignments?.filter(assignment => {
          return assignment.shift.startTime >= filterDate && assignment.shift.startTime <= filterDateEnd;
        }).length;

        // Filter assignments for current week
        pub.currentWeekAssignments = pub.assignments?.filter(assignment => {
          return assignment.shift.startTime >= currentWeekStart && assignment.shift.startTime <= currentWeekEnd;
        }).length;

        // Filter assignments for current month
        pub.currentMonthAssignments = pub.assignments?.filter(assignment => {
          return assignment.shift.startTime >= currentMonthStart && assignment.shift.startTime <= currentMonthEnd;
        }).length;

        // Filter assignments for previous month
        pub.previousMonthAssignments = pub.assignments?.filter(assignment => {
          return assignment.shift.startTime >= previousMonthStart && assignment.shift.startTime <= previousMonthEnd;
        }).length;
      });
    }
  }

  if (fetchAvailabilities) {
    //get the availabilities for the day. Calcullate:
    //1. how many days the publisher is available for the current month - only with dayOfMonth
    //2. how many days the publisher is available without dayOfMonth (previous months count)
    //3. how many hours in total the publisher is available for the current month
    publishers.forEach(pub => {
      pub.currentMonthAvailability = pub.availabilities?.filter(avail => {
        // return avail.dayOfMonth != null && avail.startTime >= currentMonthStart && avail.startTime <= currentMonthEnd;
        return avail.startTime >= currentMonthStart && avail.startTime <= currentMonthEnd;
      })
      pub.currentMonthAvailabilityDaysCount = pub.currentMonthAvailability.length || 0;
      // pub.currentMonthAvailabilityDaysCount += pub.availabilities.filter(avail => {
      //   return avail.dayOfMonth == null;
      // }).length;
      pub.currentMonthAvailabilityHoursCount = pub.currentMonthAvailability.reduce((acc, curr) => {
        return acc + (curr.endTime.getTime() - curr.startTime.getTime()) / (1000 * 60 * 60);
      }, 0);

      //if pub has ever filled the form - if has availabilities which are not from previous assignments
      pub.hasEverFilledForm = pub.availabilities?.some(avail => {
        return avail.isFromPreviousAssignments == false;
      });

      //if pub has up-to-date availabilities (with dayOfMonth) for the current month
      pub.hasUpToDateAvailabilities = pub.availabilities?.some(avail => {
        return avail.dayOfMonth != null && avail.startTime >= currentMonthStart; // && avail.startTime <= currentMonthEnd;
      });

      //if pub has availabilities for the current day
      pub.hasAvailabilityForCurrentDay = pub.availabilities?.some(avail => {
        return avail.startTime >= filterDate && avail.startTime <= filterDateEnd;
      });

    });

    if (filterDate && useDateFilter) {
      // Post filter for time if dayOfMonth is null
      // Modify the availabilities array of the filtered publishers
      publishers.forEach(pub => {
        pub.availabilities = pub.availabilities?.filter(avail => matchesAvailability(avail, filterDate));
      });
    }

  }


  return publishers;
}

function matchesAvailability(avail, filterDate) {
  // Setting the start and end time of the filterDate
  filterDate.setHours(0, 0, 0, 0);
  const filterDateEnd = new Date(filterDate);
  filterDateEnd.setHours(23, 59, 59, 999);

  // Return true if avail.startTime is between filterDate and filterDateEnd
  return avail.startTime >= filterDate && avail.startTime <= filterDateEnd;
}

async function getCalendarEvents(publisherId, date, availabilities = true, assignments = true) {
  const result = [];
  let pubs = await filterPublishers("id,firstName,lastName,email".split(","), "", date, assignments, availabilities, date ? true : false, publisherId);
  let publisher = pubs[0];
  if (publisher) {
    if (availabilities) {
      publisher.availabilities?.forEach(item => {
        result.push({
          ...item,
          title: common.getTimeFomatted(new Date(item.startTime)) + "-" + common.getTimeFomatted(new Date(item.endTime)), //item.name,
          date: new Date(item.startTime),
          startTime: new Date(item.startTime),
          endTime: new Date(item.endTime),
          publisherId: publisher.id,
          type: "availability",
          isFromPreviousAssignment: item.isFromPreviousAssignment,
        });
      });
    }
    if (assignments) {
      publisher.assignments?.forEach(item => {
        result.push({
          ...item,
          title: common.getTimeFomatted(new Date(item.shift.startTime)) + "-" + common.getTimeFomatted(new Date(item.shift.endTime)),
          date: new Date(item.shift.startTime),
          startTime: new Date(item.shift.startTime),
          endTime: new Date(item.shift.endTime),
          publisherId: item.publisherid,
          type: "assignment",
        });
      });

    }
  }
  return result;
}


async function replaceInAssignment(oldPublisherId, newPublisherId, shiftId) {
  const prisma = common.getPrismaClient();
  const result = await prisma.assignment.updateMany({
    where: {
      publisherId: oldPublisherId,
      shiftId: shiftId
    },
    data: {
      publisherId: newPublisherId,
      isConfirmed: false,
      isBySystem: true,
      isMailSent: false
    }
  });
  return result;
}