'use client'

import { createClient } from '@/lib/supabase/client'

export function getWeekdaysInRange(start: string, end: string): string[] {
  if (!start || !end || start > end) return []
  const dates: string[] = []
  const cur = new Date(start + 'T00:00:00')
  const last = new Date(end + 'T00:00:00')
  while (cur <= last) {
    const d = cur.getDay()
    if (d !== 0 && d !== 6) {
      const y = cur.getFullYear()
      const m = String(cur.getMonth() + 1).padStart(2, '0')
      const day = String(cur.getDate()).padStart(2, '0')
      dates.push(`${y}-${m}-${day}`)
    }
    cur.setDate(cur.getDate() + 1)
  }
  return dates
}

export interface VisitConflict {
  consultant_name: string
  date: string
  project_name: string
}

export async function checkVisitConflicts(params: {
  consultantIds: string[]
  startDate: string
  endDate: string
}): Promise<VisitConflict[]> {
  const supabase = createClient()
  const dates = getWeekdaysInRange(params.startDate, params.endDate)
  if (dates.length === 0 || params.consultantIds.length === 0) return []

  const { data } = await supabase
    .from('assignments')
    .select('date, consultant_id, consultants(display_name), planning_projects(name)')
    .in('consultant_id', params.consultantIds)
    .in('date', dates)

  return (data ?? []).map(c => {
    const con = Array.isArray(c.consultants) ? c.consultants[0] : c.consultants
    const pp  = Array.isArray(c.planning_projects) ? c.planning_projects[0] : c.planning_projects
    return {
      consultant_name: (con as { display_name: string | null } | null)?.display_name ?? 'Unbekannt',
      date:            c.date as string,
      project_name:    (pp  as { name: string | null } | null)?.name ?? '—',
    }
  })
}

export async function createVisitAssignments(params: {
  projectCode: string
  supplierName: string
  startDate: string
  endDate: string
  consultantIds: string[]
  source: 'auto_erstbesuch' | 'auto_folgebesuch'
  userId: string
  mode?: 'replace' | 'add'  // 'replace' (default): delete same-source first; 'add': skip delete
}): Promise<{ success: boolean; error?: string; count: number }> {
  const supabase = createClient()

  // 1. Upsert planning_projects
  const { data: pp } = await supabase
    .from('planning_projects')
    .upsert(
      { code: params.projectCode, name: params.supplierName, is_active: true },
      { onConflict: 'code' }
    )
    .select('id')
    .single()

  let planningProjectId: string | null = pp?.id ?? null
  if (!planningProjectId) {
    const { data: existing } = await supabase
      .from('planning_projects')
      .select('id')
      .eq('code', params.projectCode)
      .single()
    if (!existing) return { success: false, error: 'planning_projects Eintrag konnte nicht erstellt werden', count: 0 }
    planningProjectId = existing.id
  }

  // 2. Get weekdays in range (moved up so the replace-delete below can use it).
  const dates = getWeekdaysInRange(params.startDate, params.endDate)
  if (dates.length === 0 || params.consultantIds.length === 0) return { success: true, count: 0 }

  // 3. In 'replace' mode (= user clicked "Bestehende überschreiben"):
  // delete every existing assignment for the chosen consultants on the
  // chosen dates, regardless of source. The previous behaviour deleted
  // only same-`source` rows (e.g. only `auto_erstbesuch`), so every
  // manually-created or differently-sourced overlap stayed on the
  // calendar and the user's "overwrite" click looked like a no-op.
  if ((params.mode ?? 'replace') === 'replace') {
    const { error: delErr } = await supabase
      .from('assignments')
      .delete()
      .in('consultant_id', params.consultantIds)
      .in('date', dates)
    if (delErr) {
      return { success: false, error: `Bestehende Einträge konnten nicht gelöscht werden: ${delErr.message}`, count: 0 }
    }
  }

  // 4. Get appointment type (prefer 'erstbesuch', fall back to first)
  const { data: types } = await supabase
    .from('appointment_types')
    .select('id, code')
    .order('sort_order')
  const typeId =
    types?.find(t => t.code === 'erstbesuch')?.id ??
    types?.find(t => /kundenauftrag|visit|besuch/i.test(t.code))?.id ??
    types?.[0]?.id

  if (!typeId) return { success: false, error: 'Keine Auftragsart gefunden', count: 0 }

  // 5. Build rows
  const rows = dates.flatMap(date =>
    params.consultantIds.map(cid => ({
      date,
      consultant_id:       cid,
      project_id:          planningProjectId,
      appointment_type_id: typeId,
      status:              'tentative' as const,
      work_mode:           'onsite'    as const,
      is_all_day:          true,
      requires_travel:     false,
      is_demo:             false,
      source:              params.source,
      created_by:          params.userId,
      updated_by:          params.userId,
    }))
  )

  // 6. Insert
  const { error } = await supabase.from('assignments').insert(rows)
  if (error) return { success: false, error: error.message, count: 0 }

  return { success: true, count: rows.length }
}