//relatorio

import { Request, Response } from "express";
import AppError from "../errors/AppError";
import ShowTicketReport from "../services/TicketServices/ShowTicketReport";
import ShowMessageReport from "../services/MessageServices/ShowMessageReport";

import onlineUserService from "../services/UserServices/CreateOrUpdateOnlineUserService";
import User from "../models/User";
import Queue from "../models/Queue";
import UserOnlineTime from "../models/UserOnlineTime";

import { Op, Sequelize, literal } from "sequelize";
import format from 'date-fns/format';
import ptBR from 'date-fns/locale/pt-BR';
import { splitDateTime } from "../helpers/SplitDateTime";
import ListUserOnlineOffline from "../services/UserServices/ListUsersOnlineOfflineService";
import ListUserParamiterService from "../services/UserServices/ListUserParamiterService";

import ShowUserServiceReport from "../services/UserServices/ShowUserServiceReport";

import CountTicketsByUserQueue from "../services/UserServices/CountTicketsByUserQueue";

import ShowQueuesByUser from "../services/UserServices/ShowQueuesByUser";
import { filter } from "bluebird";



type IndexQuery = {
  userId: string;
  startDate: string;
  endDate: string;
  pageNumber: string;
};


export const reportUserByDateStartDateEnd = async (req: Request, res: Response): Promise<Response> => {

  if (req.user.profile !== "master" && req.user.profile !== "admin") {
    throw new AppError("ERR_NO_PERMISSION", 403);
  }

  const { userId, startDate, endDate, pageNumber } = req.query as IndexQuery


  console.log('PAGE NUMBER: ', pageNumber)


  const { tickets, count, hasMore } = await ShowTicketReport({ userId, startDate, endDate, pageNumber });

  // return res.status(200).json(data_query);

  return res.status(200).json({ tickets, count, hasMore });
};


export const reportUserService = async (req: Request, res: Response): Promise<Response> => {

  if (req.user.profile !== "master" && req.user.profile !== "admin") {
    throw new AppError("ERR_NO_PERMISSION", 403);
  }
  const { userId, startDate, endDate } = req.query as IndexQuery


  let usersProfile = await ListUserParamiterService({ profile: 'user' })

  const sumUserOlineTime = await ShowUserServiceReport({ startDate, endDate, userId });
  const closedByUser = await ShowUserServiceReport({ startDate, endDate, ticketStatus: 'closed', userId });
  const openByUser = await ShowUserServiceReport({ startDate, endDate, ticketStatus: 'open', userId });

  let dateTime = splitDateTime(new Date(format(new Date(), 'yyyy-MM-dd HH:mm:ss', { locale: ptBR })))
  const onlineUsers = await ListUserOnlineOffline({ date: dateTime.fullDate })

  const openByUserOnQueue = await CountTicketsByUserQueue({ startDate: startDate, endDate: endDate, status: 'open', clientChatStart: true })
  const openByUserOutQueue = await CountTicketsByUserQueue({ startDate: startDate, endDate: endDate, status: 'open', clientChatStart: false })

  const closedByUserOnQueue = await CountTicketsByUserQueue({ startDate: startDate, endDate: endDate, status: 'closed', clientChatStart: true })
  const closedUserOutQueue = await CountTicketsByUserQueue({ startDate: startDate, endDate: endDate, status: 'closed', clientChatStart: false })

  // let openQueueInOut = openByUserOnQueue.concat(openByUserOutQueue)
  // let closedQueueInOut = closedByUserOnQueue.concat(closedUserOutQueue)


  const queuesByUser = await ShowQueuesByUser({ profile: 'user' })

  let openCloseOnQueue = openByUserOnQueue.concat(closedByUserOnQueue)
  let openCloseOutQueue = openByUserOutQueue.concat(closedUserOutQueue)

  for (let i = 0; i < queuesByUser.length; i++) {
    
    queuesByUser[i].countOpen = 0
    queuesByUser[i].countClosed = 0

    for (let x = 0; x < openCloseOnQueue.length; x++) {
      if ((queuesByUser[i].userId == openCloseOnQueue[x].userId) &&
        (queuesByUser[i].queueId == openCloseOnQueue[x].queueId && openCloseOnQueue[x].status == 'open')) {
        queuesByUser[i].countOpen = openCloseOnQueue[x].totAttendance
      }
      else if ((queuesByUser[i].userId == openCloseOnQueue[x].userId) &&
        (queuesByUser[i].queueId == openCloseOnQueue[x].queueId && openCloseOnQueue[x].status == 'closed')) {
        queuesByUser[i].countClosed = openCloseOnQueue[x].totAttendance
      }
      
    }
  }


  // console.log('queuesByUser: ', queuesByUser)



  // console.log('queuesByUser: ',queuesByUser)
  // console.log()
  // console.log('CLIENT START TRUE openByUserOnQueue: ', openByUserOnQueue) 
  // console.log()
  // console.log('CLIENT START FALSE openByUserOutQueue: ', openByUserOutQueue) 
  // console.log()
  // console.log('CLIENT START TRUE closedByUserOnQueue: ', closedByUserOnQueue) 
  // console.log()
  // console.log('CLIENT START FALSE closedUserOutQueue: ', closedUserOutQueue) 


  usersProfile.map((user: any) => {

    let index = sumUserOlineTime.findIndex((e: any) => e.userId == user.id)

    if (index != -1) {
      user.sumOnlineTime = sumUserOlineTime[index];
    }

    index = closedByUser.findIndex((e: any) => e.userId == user.id)

    if (index != -1) {
      user.sumClosed = closedByUser[index];
    }

    index = openByUser.findIndex((e: any) => e.userId == user.id)

    if (index != -1) {
      user.sumOpen = openByUser[index]
    }


     


    // let openByUserOut = openQueueInOut.filter((e: any) => e.userId == user.id && !e.queueName)
    // let openByUserIn = openQueueInOut.filter((e: any) => e.userId == user.id && e.queueName)

    // if (openByUserOut && openByUserOut.length > 0) {
    //   user.openTicketByUserOut = openByUserOut
    // }
    // if (openByUserIn && openByUserIn.length > 0) {
    //   user.openTicketByUserIn = openByUserIn
    // }

    // let closedByUserOut = closedQueueInOut.filter((e: any) => e.userId == user.id && !e.queueName)
    // let closedByUserIn = closedQueueInOut.filter((e: any) => e.userId == user.id && e.queueName)

    // if (closedByUserOut && closedByUserOut.length > 0) {
    //   user.closedTicketByUserOut = closedByUserOut
    // }
    // if (closedByUserIn && closedByUserIn.length > 0) {
    //   user.closedTicketByUserIn = closedByUserIn
    // }





    // OPEN, CLOSED TICKETS STARTED BY USERS
    let openClosedOutQueue = {}
    let open = openCloseOutQueue.filter((e) => e.userId == user.id && e.status == 'open')
    let closed = openCloseOutQueue.filter((e) => e.userId == user.id && e.status == 'closed')

    openClosedOutQueue = {
      ...openClosedOutQueue,
      userId: user.id,
      countOpen: open && open.length > 0 ? open[0].totAttendance : 0,
      countClosed: closed && closed.length > 0 ? closed[0].totAttendance : 0
    }

    user.openClosedOutQueue = openClosedOutQueue


    // OPEN, CLOSED TICKETS STARTED BY CLIENTS
    let openClosedInQueue = queuesByUser.filter((e) => e.userId == user.id)

    if (openClosedInQueue && openClosedInQueue.length > 0) {
      user.openClosedInQueue = openClosedInQueue 
    }








    index = onlineUsers.findIndex((e: any) => e.userId == user.id)

    if (index != -1) {
      user.statusOnline = onlineUsers[index]
    }

    if (startDate.length > 0 && startDate.split('-').length == 3) {
      let date = startDate.split('-')
      user.startDate = `${date[2]}/${date[1]}/${date[0]}`
    }

    if (endDate.length > 0 && endDate.split('-').length == 3) {
      let date = endDate.split('-')
      user.endDate = `${date[2]}/${date[1]}/${date[0]}`
    }

  })

  return res.status(200).json(usersProfile);

};



export const reportMessagesUserByDateStartDateEnd = async (req: Request, res: Response): Promise<Response> => {

  if (req.user.profile !== "master" && req.user.profile !== "admin") {
    throw new AppError("ERR_NO_PERMISSION", 403);
  }

  const { userId, startDate, endDate } = req.query as IndexQuery

  const data_query_messages = await ShowMessageReport(userId, startDate, endDate);

  return res.status(200).json(data_query_messages);

};