import { getChatProvider } from '../factory'
import { getSystemConfig } from '@/lib/config'

export interface StudyDay {
  date: string
  noteIds: string[]
  noteTitles: string[]
  activity: string
}

export interface StudyPlan {
  days: StudyDay[]
  totalDays: number
  notesPerDay: number
}

export class StudyPlannerService {
  async generate(
    notes: Array<{ id: string; title: string }>,
    examDate: string,
    language?: string
  ): Promise<StudyPlan> {
    const lang = language || 'fr'
    const langName = lang === 'fr' ? 'français' : lang === 'fa' ? 'فارسی' : 'English'

    const exam = new Date(examDate)
    const today = new Date()
    today.setHours(0, 0, 0, 0)
    const daysUntilExam = Math.max(1, Math.ceil((exam.getTime() - today.getTime()) / (1000 * 60 * 60 * 24)))

    const notesList = notes.map((n, i) => `${i + 1}. ${n.title} (id: ${n.id})`).join('\n')

    const prompt = `Tu es un expert en pédagogie et apprentissage. Crée un planning de révision optimisé.

DATE DE L'EXAMEN : ${examDate}
JOURS RESTANTS : ${daysUntilExam}
LANGUE : ${langName}

NOTES À RÉVISER :
${notesList}

Crée un planning qui répartit ces notes sur ${daysUntilExam} jours en utilisant la répétition espacée :
- Les premiers jours : couvrir tout le programme une fois
- Les jours suivants : revoir les notes difficiles plus fréquemment
- Les derniers jours : révision globale et fiches synthèses
- Inclus des jours de repos légers (relecture rapide)

FORMAT JSON UNIQUEMENT :
\`\`\`json
{
  "days": [
    {
      "date": "YYYY-MM-DD",
      "noteIds": ["id1", "id2"],
      "activity": "Description courte de l'activité du jour"
    }
  ]
}
\`\`\`

Génère exactement ${Math.min(daysUntilExam, 30)} entrées de jours (max 30).
Les dates vont de aujourd'hui (${today.toISOString().slice(0, 10)}) jusqu'à la veille de l'examen.
Chaque jour doit avoir 1-4 notes à réviser avec une activité descriptive.`

    const config = await getSystemConfig()
    const provider = getChatProvider(config)
    const raw = await provider.generateText(prompt)

    return this.parseResponse(raw, notes, daysUntilExam)
  }

  private parseResponse(
    raw: string,
    notes: Array<{ id: string; title: string }>,
    totalDays: number
  ): StudyPlan {
    const jsonMatch = raw.match(/```json\s*([\s\S]+?)\s*```/)
    let jsonStr = jsonMatch ? jsonMatch[1] : raw

    const start = jsonStr.indexOf('{')
    const end = jsonStr.lastIndexOf('}')
    if (start >= 0 && end > start) {
      jsonStr = jsonStr.slice(start, end + 1)
    }

    try {
      const parsed = JSON.parse(jsonStr)
      const titleMap = new Map(notes.map(n => [n.id, n.title]))

      const days: StudyDay[] = (parsed.days || []).map((d: any) => ({
        date: String(d.date || ''),
        noteIds: Array.isArray(d.noteIds) ? d.noteIds.map(String) : [],
        noteTitles: (Array.isArray(d.noteIds) ? d.noteIds : []).map((id: string) => titleMap.get(id) || 'Note'),
        activity: String(d.activity || 'Révision'),
      }))

      return {
        days,
        totalDays: days.length,
        notesPerDay: days.length > 0 ? Math.round(notes.length / days.length) : 0,
      }
    } catch {
      // Fallback: simple distribution
      const days: StudyDay[] = []
      const today = new Date()
      const notesPerDay = Math.max(1, Math.ceil(notes.length / Math.min(totalDays, 14)))
      for (let i = 0; i < Math.min(totalDays, 14); i++) {
        const date = new Date(today)
        date.setDate(date.getDate() + i)
        const dayNotes = notes.slice(i * notesPerDay, (i + 1) * notesPerDay)
        if (dayNotes.length === 0 && i > 0) break
        days.push({
          date: date.toISOString().slice(0, 10),
          noteIds: dayNotes.map(n => n.id),
          noteTitles: dayNotes.map(n => n.title),
          activity: i === 0 ? 'Première lecture' : `Revoir ${dayNotes.length} notes`,
        })
      }

      return { days, totalDays: days.length, notesPerDay }
    }
  }
}

export const studyPlannerService = new StudyPlannerService()