import { string, date } from 'alga-js'
import refreshTokenHelper from '../../utils/refreshTokenHelper'
import errorHandlingHelper from '../../utils/errorHandlingHelper'
import fetchHelper from '../../utils/fetchHelper'

function getDateRange(period: string) {
  const now = new Date()
  let startDate: string
  let endDate: string
  let prevStartDate: string
  let prevEndDate: string

  const fmt = (d: Date) => d.toISOString().split('T')[0]

  if (period === 'today') {
    const today = fmt(now)
    startDate = today + ' 00:00:00'
    endDate = today + ' 23:59:59'
    const yesterday = new Date(now)
    yesterday.setDate(yesterday.getDate() - 1)
    prevStartDate = fmt(yesterday) + ' 00:00:00'
    prevEndDate = fmt(yesterday) + ' 23:59:59'
  } else if (period === 'yesterday') {
    const yesterday = new Date(now)
    yesterday.setDate(yesterday.getDate() - 1)
    startDate = fmt(yesterday) + ' 00:00:00'
    endDate = fmt(yesterday) + ' 23:59:59'
    const dayBefore = new Date(now)
    dayBefore.setDate(dayBefore.getDate() - 2)
    prevStartDate = fmt(dayBefore) + ' 00:00:00'
    prevEndDate = fmt(dayBefore) + ' 23:59:59'
  } else if (period === 'last_month') {
    const start = new Date(now)
    start.setDate(start.getDate() - 30)
    startDate = fmt(start) + ' 00:00:00'
    endDate = fmt(now) + ' 23:59:59'
    const prevStart = new Date(start)
    prevStart.setDate(prevStart.getDate() - 30)
    prevStartDate = fmt(prevStart) + ' 00:00:00'
    prevEndDate = fmt(start) + ' 23:59:59'
  } else if (period === 'last_quarter') {
    const start = new Date(now)
    start.setDate(start.getDate() - 90)
    startDate = fmt(start) + ' 00:00:00'
    endDate = fmt(now) + ' 23:59:59'
    const prevStart = new Date(start)
    prevStart.setDate(prevStart.getDate() - 90)
    prevStartDate = fmt(prevStart) + ' 00:00:00'
    prevEndDate = fmt(start) + ' 23:59:59'
  } else if (period === 'last_year') {
    const start = new Date(now)
    start.setFullYear(start.getFullYear() - 1)
    startDate = fmt(start) + ' 00:00:00'
    endDate = fmt(now) + ' 23:59:59'
    const prevStart = new Date(start)
    prevStart.setFullYear(prevStart.getFullYear() - 1)
    prevStartDate = fmt(prevStart) + ' 00:00:00'
    prevEndDate = fmt(start) + ' 23:59:59'
  } else {
    // default: last_week (7 days)
    const start = new Date(now)
    start.setDate(start.getDate() - 7)
    startDate = fmt(start) + ' 00:00:00'
    endDate = fmt(now) + ' 23:59:59'
    const prevStart = new Date(start)
    prevStart.setDate(prevStart.getDate() - 7)
    prevStartDate = fmt(prevStart) + ' 00:00:00'
    prevEndDate = fmt(start) + ' 23:59:59'
  }

  return { startDate, endDate, prevStartDate, prevEndDate }
}

async function fetchCount(event: any, token: string, model: string, filter: string): Promise<number> {
  try {
    const encodedFilter = string.urlEncode(filter)
    const res: any = await fetchHelper(event, `models/${model}?$filter=${encodedFilter}&$select=created&$top=1`, 'GET', token, null)
    return res?.['row-count'] ?? 0
  } catch {
    return 0
  }
}

async function fetchSum(event: any, token: string, model: string, filter: string, field: string): Promise<number> {
  try {
    const encodedFilter = string.urlEncode(filter)
    const res: any = await fetchHelper(event, `models/${model}?$filter=${encodedFilter}&$select=${field}`, 'GET', token, null)
    const records = res?.records || []
    return records.reduce((sum: number, r: any) => sum + (Number(r[field]) || 0), 0)
  } catch {
    return 0
  }
}

const handleFunc = async (event: any, authToken: any = null) => {
  const token = authToken ?? await getTokenHelper(event)
  const query = getQuery(event)
  const organizationId = getCookie(event, 'logship_organization_id')
  const role = getCookie(event, 'logship_role')
  const period = (query?.period as string) || 'last_week'
  const orgIdParam = query?.org_id as string

  const { startDate, endDate, prevStartDate, prevEndDate } = getDateRange(period)

  const newUserRole = JSON.parse(role ?? '{}')
  let orgFilter = ''
  if (!newUserRole?.IsClientAdministrator) {
    orgFilter = ` AND ad_org_id eq ${orgIdParam || organizationId}`
  } else if (orgIdParam) {
    orgFilter = ` AND ad_org_id eq ${orgIdParam}`
  }

  const soFilter = `IsSOTrx eq true AND created ge '${startDate}' AND created le '${endDate}'${orgFilter}`
  const prevSoFilter = `IsSOTrx eq true AND created ge '${prevStartDate}' AND created le '${prevEndDate}'${orgFilter}`
  const dateFilter = `created ge '${startDate}' AND created le '${endDate}'${orgFilter}`
  const prevDateFilter = `created ge '${prevStartDate}' AND created le '${prevEndDate}'${orgFilter}`
  const openOrderFilter = `IsSOTrx eq true AND DocStatus eq 'CO'${orgFilter}`

  // Fetch current period data
  const [
    ordersCount, prevOrdersCount,
    revenue, prevRevenue,
    shipmentsCount, prevShipmentsCount,
    invoiceTotal, prevInvoiceTotal,
    openOrdersCount
  ] = await Promise.all([
    fetchCount(event, token, 'c_order', soFilter),
    fetchCount(event, token, 'c_order', prevSoFilter),
    fetchSum(event, token, 'c_order', soFilter, 'GrandTotal'),
    fetchSum(event, token, 'c_order', prevSoFilter, 'GrandTotal'),
    fetchCount(event, token, 'm_inout', dateFilter),
    fetchCount(event, token, 'm_inout', prevDateFilter),
    fetchSum(event, token, 'c_invoice', `IsSOTrx eq true AND created ge '${startDate}' AND created le '${endDate}'${orgFilter}`, 'GrandTotal'),
    fetchSum(event, token, 'c_invoice', `IsSOTrx eq true AND created ge '${prevStartDate}' AND created le '${prevEndDate}'${orgFilter}`, 'GrandTotal'),
    fetchCount(event, token, 'c_order', openOrderFilter),
  ])

  const avgOrderValue = ordersCount > 0 ? Math.round((revenue / ordersCount) * 100) / 100 : 0
  const prevAvgOrderValue = prevOrdersCount > 0 ? Math.round((prevRevenue / prevOrdersCount) * 100) / 100 : 0

  return {
    orders: { current: ordersCount, previous: prevOrdersCount },
    revenue: { current: Math.round(revenue * 100) / 100, previous: Math.round(prevRevenue * 100) / 100 },
    shipments: { current: shipmentsCount, previous: prevShipmentsCount },
    openOrders: { current: openOrdersCount, previous: 0 },
    invoiceTotal: { current: Math.round(invoiceTotal * 100) / 100, previous: Math.round(prevInvoiceTotal * 100) / 100 },
    avgOrderValue: { current: avgOrderValue, previous: prevAvgOrderValue },
  }
}

export default defineEventHandler(async (event) => {
  let data: any = {}

  try {
    data = await handleFunc(event)
  } catch (err: any) {
    try {
      const authToken: any = await refreshTokenHelper(event)
      data = await handleFunc(event, authToken)
    } catch (error: any) {
      data = errorHandlingHelper(err?.data ?? err, error?.data ?? error)
    }
  }

  return data
})