import pg from 'pg'

const { Client } = pg

const dbUrl = process.env.DATABASE_URL ?? 'postgres://user:password@localhost:5430/orbit_dev'

const targetEmail = process.env.SEED_EMAIL ?? 'porcellis@eletrotupi.com'

const DAYS = 35

// Reproducible PRNG so the demo dataset is stable between runs.

function mulberry32(seed) {

  return function () {

    seed |= 0

    seed = (seed + 0x6d2b79f5) | 0

    let t = Math.imul(seed ^ (seed >>> 15), 1 | seed)

    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t

    return ((t ^ (t >>> 14)) >>> 0) / 4294967296

  }

}

const rand = mulberry32(20261019)

const pick = (arr) => arr[Math.floor(rand() * arr.length)]

const between = (min, max) => Math.floor(rand() * (max - min + 1)) + min

const round1 = (n) => Math.round(n * 10) / 10

function localDateStr(d) {

  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`

}

// ---- mood ----

function pickMood() {

  const r = rand()

  if (r < 0.15) return 'GREAT'

  if (r < 0.5) return 'GOOD'

  if (r < 0.75) return 'NEUTRAL'

  if (r < 0.9) return 'SAD'

  return 'ANGRY'

}

const MOOD_LEVELS = {

  GREAT: { energy: [7, 9], stress: [1, 3], anxiety: [1, 3] },

  GOOD: { energy: [6, 8], stress: [2, 4], anxiety: [2, 4] },

  NEUTRAL: { energy: [4, 6], stress: [3, 5], anxiety: [3, 5] },

  SAD: { energy: [2, 4], stress: [4, 6], anxiety: [5, 7] },

  ANGRY: { energy: [4, 6], stress: [7, 9], anxiety: [6, 8] },

}

const MOOD_COMPONENTS = {

  GREAT: ['JOY', 'GRATITUDE', 'MOTIVATED', 'CALM'],

  GOOD: ['CALM', 'FOCUS', 'RELAXED', 'MOTIVATED'],

  NEUTRAL: ['CALM', 'TIREDNESS', 'FOCUS', 'RELAXED'],

  SAD: ['SADNESS', 'TIREDNESS', 'OVERWHELMED', 'GUILT', 'FEAR'],

  ANGRY: ['ANGER', 'FRUSTRATION', 'RESTLESS'],

}

const MOOD_ANNOTATIONS = {

  GREAT: ['Dia muito produtivo', 'Acordei bem disposto', 'Me senti leve e animado', null],

  GOOD: ['Dia tranquilo', 'Boa noite de sono', 'Trabalho rendeu bem', null],

  NEUTRAL: ['Nada de especial hoje', 'Rotina normal', 'Cansado, mas ok', null],

  SAD: ['Noite mal dormida', 'Me senti para baixo', 'Sem energia hoje', null],

  ANGRY: ['Estresse no trabalho', 'Briga em casa', 'Trânsito me irritou', null],

}

const INTENSITIES = ['LIGHT', 'MODERATE', 'HIGH']

function componentsFor(mood) {

  const pool = MOOD_COMPONENTS[mood]

  const count = between(1, Math.min(3, pool.length))

  const chosen = new Set()

  while (chosen.size < count) chosen.add(pick(pool))

  return [...chosen].map((component) => {

    let intensity = pick(INTENSITIES)

    if (['ANGER', 'FEAR', 'OVERWHELMED', 'FRUSTRATION'].includes(component) && intensity === 'LIGHT') {

      intensity = 'MODERATE'

    }

    if (['CALM', 'RELAXED'].includes(component) && intensity === 'HIGH') {

      intensity = 'MODERATE'

    }

    return { component, intensity }

  })

}

// ---- sleep ----

const SLEEP_NOTES = ['Boa noite de sono', 'Acordei de madrugada', 'Demorei para pegar no sono', 'Sono leve', null]

// ---- triggers ----

const TRIGGER_POOL = [

  { category: 'WORK', comment: 'Reunião estressante no trabalho' },

  { category: 'WORK', comment: 'Prazo apertado no projeto' },

  { category: 'FAMILY', comment: 'Discussão em família' },

  { category: 'PHYSICAL', comment: 'Noite mal dormida' },

  { category: 'PHYSICAL', comment: 'Dor de cabeça forte' },

  { category: 'INTERNAL', comment: 'Pensamentos ansiosos' },

  { category: 'INTERNAL', comment: 'Sentimento de culpa' },

  { category: 'SOCIAL', comment: 'Encontro com amigos' },

  { category: 'SOCIAL', comment: 'Evento social no fim de semana' },

  { category: 'HEALTH', comment: 'Consulta de rotina' },

  { category: 'THERAPY', comment: 'Sessão de terapia' },

  { category: 'FAMILY', comment: 'Visita de parentes' },

]

// ---- medicine ----

const REGIMENS = [

  { name: 'Lítio', dosage: '300 mg', periodicity: 'DAILY', scheduledAt: ['20:00'] },

  { name: 'Lamotrigina', dosage: '100 mg', periodicity: 'DAILY', scheduledAt: ['08:00'] },

]

// ---- activities ----

const ACTIVITY_POOL = [

  { type: 'WALK', duration: 30 },

  { type: 'WALK', duration: 45 },

  { type: 'MEDITATION', duration: 15 },

  { type: 'GYM', duration: 60 },

  { type: 'YOGA', duration: 45 },

  { type: 'CREATIVE', duration: 60 },

  { type: 'SOCIAL', duration: 90 },

]

async function main() {

  const db = new Client({ connectionString: dbUrl })

  await db.connect()

  try {

    const { rows } = await db.query(

      'SELECT id, first_name, last_name FROM users WHERE email = $1',

      [targetEmail],

    )

    if (rows.length === 0) {

      console.error(`User ${targetEmail} not found`)

      process.exitCode = 1

      return

    }

    const user = rows[0]

    const userId = user.id

    // Wipe existing demo data, children first (FK-safe order).

    await db.query('DELETE FROM care_actions WHERE user_id = $1', [userId])

    await db.query('DELETE FROM medicine_regimens WHERE user_id = $1', [userId])

    await db.query('DELETE FROM triggers WHERE user_id = $1', [userId])

    await db.query('DELETE FROM sleep_records WHERE user_id = $1', [userId])

    await db.query('DELETE FROM moods WHERE user_id = $1', [userId])

    await db.query('DELETE FROM insights WHERE user_id = $1', [userId])

    const now = new Date()

    const dayAt = (offset) => {

      const d = new Date(now)

      d.setDate(now.getDate() - offset)

      return d

    }

    const counts = { moods: 0, sleep: 0, triggers: 0, medicine: 0, activities: 0 }

    // moods

    for (let d = DAYS; d >= 0; d--) {

      const r = rand()

      const count = r < 0.05 ? 0 : r < 0.5 ? 1 : r < 0.85 ? 2 : 3

      for (let i = 0; i < count; i++) {

        const mood = pickMood()

        const levels = MOOD_LEVELS[mood]

        const moment = new Date(dayAt(d))

        moment.setHours(pick([9, 12, 15, 18, 21]) + between(0, 2), between(0, 59), 0, 0)

        const res = await db.query(

          `INSERT INTO moods

             (user_id, selected_mood, energy_level, stress_level, anxiety_level, annotation, moment)

           VALUES ($1, $2, $3, $4, $5, $6, $7)

           RETURNING id`,

          [

            userId,

            mood,

            between(...levels.energy),

            between(...levels.stress),

            between(...levels.anxiety),

            pick(MOOD_ANNOTATIONS[mood]),

            moment,

          ],

        )

        for (const c of componentsFor(mood)) {

          await db.query(

            'INSERT INTO mood_components (mood_id, component, intensity) VALUES ($1, $2, $3)',

            [res.rows[0].id, c.component, c.intensity],

          )

        }

        counts.moods++

      }

    }

    // sleep records — one per night

    for (let d = DAYS; d >= 0; d--) {

      const day = dayAt(d)

      const average = round1(5.5 + rand() * 3)

      const note = pick(SLEEP_NOTES)

      await db.query(

        'INSERT INTO sleep_records (user_id, average, date, annotations, updated_at) VALUES ($1, $2, $3, $4, NOW())',

        [userId, average, localDateStr(day), note],

      )

      counts.sleep++

    }

    // triggers

    for (let i = 0; i < TRIGGER_POOL.length; i++) {

      const t = TRIGGER_POOL[i]

      const moment = new Date(dayAt(between(0, DAYS)))

      moment.setHours(between(8, 21), between(0, 59), 0, 0)

      await db.query(

        'INSERT INTO triggers (user_id, category, moment, comment, updated_at) VALUES ($1, $2, $3, $4, NOW())',

        [userId, t.category, moment, t.comment],

      )

      counts.triggers++

    }

    // medicine regimens + logs

    for (const r of REGIMENS) {

      const reg = await db.query(

        `INSERT INTO medicine_regimens (user_id, name, dosage, periodicity, scheduled_at, active, updated_at)

         VALUES ($1, $2, $3, $4, $5, true, NOW())

         RETURNING id`,

        [userId, r.name, r.dosage, r.periodicity, r.scheduledAt],

      )

      const regimenId = reg.rows[0].id

      for (let d = DAYS; d >= 0; d--) {

        if (rand() < 0.25) continue

        const moment = new Date(dayAt(d))

        const [h, m] = pick(r.scheduledAt).split(':').map(Number)

        moment.setHours(h, m, 0, 0)

        const ca = await db.query(

          "INSERT INTO care_actions (user_id, type, moment, updated_at) VALUES ($1, 'MEDICINE', $2, NOW()) RETURNING id",

          [userId, moment],

        )

        await db.query(

          'INSERT INTO medicine_logs (care_action_id, regimen_id, taken_at) VALUES ($1, $2, $3)',

          [ca.rows[0].id, regimenId, moment],

        )

        counts.medicine++

      }

    }

    // activities

    for (let i = 0; i < 10; i++) {

      const a = pick(ACTIVITY_POOL)

      const moment = new Date(dayAt(between(0, DAYS)))

      moment.setHours(between(7, 20), between(0, 59), 0, 0)

      const ca = await db.query(

        "INSERT INTO care_actions (user_id, type, moment, updated_at) VALUES ($1, 'ACTIVITY', $2, NOW()) RETURNING id",

        [userId, moment],

      )

      await db.query(

        'INSERT INTO activities (care_action_id, type, duration) VALUES ($1, $2, $3)',

        [ca.rows[0].id, a.type, a.duration],

      )

      counts.activities++

    }

    const name = [user.first_name, user.last_name].filter(Boolean).join(' ')

    console.log(`Seeded demo data for ${targetEmail} (id ${user.id}, ${name})`)

    console.log(counts)

  } finally {

    await db.end()

  }

}

main().catch((err) => {

  console.error(err)

  process.exit(1)

})