// db.js — SQLite database layer voor Padel Planner API
const Database = require('better-sqlite3');
const path = require('path');
const fs = require('fs');

const DB_PATH = process.env.DB_PATH || '/data/data.db';

let db;

function getDb() {
  if (!db) {
    const dir = path.dirname(DB_PATH);
    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
    db = new Database(DB_PATH);
    db.pragma('journal_mode = WAL');     // faster writes
    db.pragma('foreign_keys = ON');
    migrateSchema();
  }
  return db;
}

function migrateSchema() {
  db.exec(`
    CREATE TABLE IF NOT EXISTS players (
      id           TEXT PRIMARY KEY,
      name         TEXT NOT NULL,
      level        INTEGER NOT NULL DEFAULT 5,
      position     TEXT NOT NULL DEFAULT 'Beide',
      telegram_id  TEXT,
      pin          TEXT,
      sessions     INTEGER NOT NULL DEFAULT 0,
      hours        INTEGER NOT NULL DEFAULT 0,
      wins         INTEGER NOT NULL DEFAULT 0,
      games        INTEGER NOT NULL DEFAULT 0,
      avail_mode   TEXT NOT NULL DEFAULT 'flex',
      created_at   TEXT NOT NULL DEFAULT (datetime('now'))
    );

    CREATE TABLE IF NOT EXISTS player_availability (
      id          INTEGER PRIMARY KEY AUTOINCREMENT,
      player_id   TEXT NOT NULL REFERENCES players(id) ON DELETE CASCADE,
      day_name    TEXT NOT NULL,   -- 'maandag', 'dinsdag', ...
      start_time  TEXT NOT NULL,   -- 'HH:MM'
      end_time    TEXT NOT NULL,   -- 'HH:MM'
      duration    INTEGER NOT NULL DEFAULT 90
    );

    CREATE INDEX IF NOT EXISTS idx_avail_player ON player_availability(player_id);
    CREATE INDEX IF NOT EXISTS idx_avail_day   ON player_availability(day_name);

    CREATE TABLE IF NOT EXISTS matches (
      id           TEXT PRIMARY KEY,
      status       TEXT NOT NULL DEFAULT 'proposed',
      responses    TEXT NOT NULL DEFAULT '{}',
      proposed_at  TEXT NOT NULL DEFAULT (datetime('now')),
      date         TEXT,
      start        TEXT,
      end          TEXT,
      location     TEXT,
      day          TEXT,
      score        TEXT,           -- JSON score object
      booker_id    TEXT,           -- player id who should book
      booker_name  TEXT,
      created_at   TEXT NOT NULL DEFAULT (datetime('now'))
    );

    CREATE TABLE IF NOT EXISTS match_players (
      id         INTEGER PRIMARY KEY AUTOINCREMENT,
      match_id   TEXT NOT NULL REFERENCES matches(id) ON DELETE CASCADE,
      player_id  TEXT NOT NULL REFERENCES players(id) ON DELETE CASCADE,
      team       INTEGER,  -- 1 or 2 (for scoring)
      score      TEXT      -- player's submitted score JSON
    );

    CREATE INDEX IF NOT EXISTS idx_matchp_match ON match_players(match_id);
    CREATE INDEX IF NOT EXISTS idx_matchp_player ON match_players(player_id);

    CREATE TABLE IF NOT EXISTS sessions (
      id           TEXT PRIMARY KEY,
      player_id    TEXT REFERENCES players(id) ON DELETE SET NULL,
      data         TEXT NOT NULL DEFAULT '{}',
      created_at   TEXT NOT NULL DEFAULT (datetime('now')),
      updated_at   TEXT NOT NULL DEFAULT (datetime('now'))
    );

    CREATE INDEX IF NOT EXISTS idx_sesh_player ON sessions(player_id);

    CREATE TABLE IF NOT EXISTS settings (
      key   TEXT PRIMARY KEY,
      value TEXT
    );

    CREATE TABLE IF NOT EXISTS player_match_stats (
      player_id TEXT NOT NULL REFERENCES players(id) ON DELETE CASCADE,
      match_id  TEXT NOT NULL REFERENCES matches(id) ON DELETE CASCADE,
      PRIMARY KEY (player_id, match_id)
  );
  `);
}

// ─── Players ───

function getPlayers() {
  const db = getDb();
  const rows = db.prepare(`
    SELECT p.*, json_group_array(
      json_object('day_name', a.day_name, 'start', a.start_time, 'end', a.end_time, 'duration', a.duration)
    ) FILTER (WHERE a.id IS NOT NULL) as availability_arr
    FROM players p
    LEFT JOIN player_availability a ON a.player_id = p.id
    GROUP BY p.id
  `).all();

  return rows.map(r => rowToPlayer(r));
}

function getPlayer(id) {
  const db = getDb();
  const r = db.prepare(`
    SELECT p.*, json_group_array(
      json_object('day_name', a.day_name, 'start', a.start_time, 'end', a.end_time, 'duration', a.duration)
    ) FILTER (WHERE a.id IS NOT NULL) as availability_arr
    FROM players p
    LEFT JOIN player_availability a ON a.player_id = p.id
    WHERE p.id = ?
    GROUP BY p.id
  `).get(id);
  return r ? rowToPlayer(r) : null;
}

function getPlayerByTelegram(telegramId) {
  const db = getDb();
  const r = db.prepare(`
    SELECT p.*, json_group_array(
      json_object('day_name', a.day_name, 'start', a.start_time, 'end', a.end_time, 'duration', a.duration)
    ) FILTER (WHERE a.id IS NOT NULL) as availability_arr
    FROM players p
    LEFT JOIN player_availability a ON a.player_id = p.id
    WHERE p.telegram_id = ?
    GROUP BY p.id
  `).get(telegramId);
  return r ? rowToPlayer(r) : null;
}

function addPlayer(player) {
  const db = getDb();
  const id = player.id || String(Date.now());
  const stmt = db.prepare(`
    INSERT INTO players (id, name, level, position, telegram_id, pin, sessions, hours, wins, games, avail_mode, availability_temp)
    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
  `);
  stmt.run(id, player.name, player.level || 5, player.position || 'Beide',
           String(player.telegram_id || ''), String(player.pin || ''),
           player.sessions || 0, player.hours || 0,
           player.wins || 0, player.games || 0,
           player.avail_mode || 'flex',
           player.availability_temp || null);
  setPlayerAvailability(id, player.availability || {});
  return getPlayer(id);
}

function updatePlayer(id, player) {
  const db = getDb();
  const existing = getPlayer(id);
  if (!existing) return null;

  const merged = { ...existing, ...player };
  db.prepare(`
    UPDATE players SET name=?, level=?, position=?, telegram_id=?, pin=?,
      sessions=?, hours=?, wins=?, games=?, avail_mode=?, availability_temp=?
    WHERE id=?
  `).run(
    merged.name, merged.level, merged.position,
    String(merged.telegram_id || ''), String(merged.pin || ''),
    merged.sessions, merged.hours, merged.wins, merged.games,
    merged.avail_mode, merged.availability_temp || null, id
  );

  if (player.availability !== undefined) {
    setPlayerAvailability(id, player.availability);
  }

  return getPlayer(id);
}

function deletePlayer(id) {
  if (!id) return false;
  const db = getDb();
  db.prepare(`DELETE FROM player_availability WHERE player_id = ?`).run(id);
  db.prepare(`DELETE FROM match_players WHERE player_id = ?`).run(id);
  db.prepare(`DELETE FROM sessions WHERE player_id = ?`).run(id);
  const result = db.prepare(`DELETE FROM players WHERE id = ?`).run(id);
  return result.changes > 0;
}

// ─── Availability helpers ───

function setPlayerAvailability(playerId, availability) {
  const db = getDb();
  db.prepare(`DELETE FROM player_availability WHERE player_id = ?`).run(playerId);

  // availability = { "maandag": [{start, end, duration}], ... }
  for (const [dayName, slots] of Object.entries(availability)) {
    if (dayName === 'isSet') continue;
    if (Array.isArray(slots) && slots.length > 0 && slots[0] && slots[0].start) {
      const stmt = db.prepare(`
        INSERT INTO player_availability (player_id, day_name, start_time, end_time, duration)
        VALUES (?, ?, ?, ?, ?)
      `);
      for (const slot of slots) {
        stmt.run(playerId, dayName, slot.start, slot.end, slot.duration || 90);
      }
    }
  }
}

// ─── Matches ───

function getMatches() {
  const db = getDb();
  const rows = db.prepare(`
    SELECT m.*, json_group_array(
      json_object('player_id', mp.player_id, 'team', mp.team, 'score', mp.score)
    ) FILTER (WHERE mp.id IS NOT NULL) as players_arr
    FROM matches m
    LEFT JOIN match_players mp ON mp.match_id = m.id
    GROUP BY m.id
    ORDER BY m.created_at DESC
  `).all();

  return rows.map(r => rowToMatch(r));
}

function getMatch(id) {
  const db = getDb();
  const r = db.prepare(`
    SELECT m.*, json_group_array(
      json_object('player_id', mp.player_id, 'team', mp.team, 'score', mp.score)
    ) FILTER (WHERE mp.id IS NOT NULL) as players_arr
    FROM matches m
    LEFT JOIN match_players mp ON mp.match_id = m.id
    WHERE m.id = ?
    GROUP BY m.id
  `).get(id);
  return r ? rowToMatch(r) : null;
}

function addMatch(match) {
  const db = getDb();
  const id = match.id || String(Date.now());
  const stmt = db.prepare(`
    INSERT INTO matches (id, status, responses, proposed_at, date, start, end, location, day, score, booker_id, booker_name)
    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
  `);
  stmt.run(id, match.status || 'proposed',
           JSON.stringify(match.responses || {}),
           match.proposed_at || new Date().toISOString(),
           match.date || null, match.start || null,
           match.end || null, match.location || null,
           match.day || null,
           typeof match.score === 'object' ? JSON.stringify(match.score) : (match.score || null),
           match.booker_id || null,
           match.booker_name || null);

  if (Array.isArray(match.players)) {
    const pstmt = db.prepare(`INSERT INTO match_players (match_id, player_id, team, score) VALUES (?, ?, ?, ?)`);
    for (const p of match.players) {
      const pid = typeof p === 'object' ? p.id || p.player_id : p;
      pstmt.run(id, pid, p.team || null, p.score || null);
    }
  }

  return getMatch(id);
}

function updateMatch(id, match) {
  const db = getDb();
  const existing = getMatch(id);
  if (!existing) return null;

  const merged = { ...existing, ...match };

  const responsesStr = typeof merged.responses === 'object'
    ? JSON.stringify(merged.responses) : merged.responses;

  // Build SET dynamically to only update provided fields
  const fields = [];
  const values = [];
  for (const key of ['status', 'responses', 'proposed_at', 'date', 'start', 'end', 'location', 'day', 'score', 'booker_id', 'booker_name', 'proposed_teams']) {
    if (match[key] !== undefined) {
      fields.push(`${key}=?`);
      let val = merged[key];
      if (key === 'responses' || key === 'score' || key === 'proposed_teams') {
        val = JSON.stringify(val);
      }
      values.push(key === 'booker_id' || key === 'booker_name' ? String(val) : val);
    }
  }
  if (fields.length > 0) {
    values.push(id);
    db.prepare(`UPDATE matches SET ${fields.join(', ')} WHERE id=?`).run(...values);
  }

  if (match.players !== undefined) {
    db.prepare(`DELETE FROM match_players WHERE match_id = ?`).run(id);
    if (Array.isArray(match.players)) {
      const pstmt = db.prepare(`INSERT INTO match_players (match_id, player_id, team, score) VALUES (?, ?, ?, ?)`);
      for (const p of match.players) {
        const pid = typeof p === 'object' ? p.id || p.player_id : p;
        pstmt.run(id, pid, p.team || null, p.score || null);
      }
    }
  }

  return getMatch(id);
}

function deleteMatch(id) {
  if (!id) return false;
  const db = getDb();
  db.prepare(`DELETE FROM match_players WHERE match_id = ?`).run(id);
  const result = db.prepare(`DELETE FROM matches WHERE id = ?`).run(id);
  return result.changes > 0;
}

// ─── Sessions ───

function getSessions() {
  const db = getDb();
  return db.prepare(`SELECT * FROM sessions`).all().map(r => ({
    ...r,
    data: safeJsonParse(r.data, {})
  }));
}

function getSession(id) {
  const db = getDb();
  const r = db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(id);
  if (!r) return null;
  return { ...r, data: safeJsonParse(r.data, {}) };
}

function setSession(id, playerId, data) {
  const db = getDb();
  const dataStr = JSON.stringify(data || {});
  const existing = db.prepare(`SELECT id FROM sessions WHERE id = ?`).get(id);
  if (existing) {
    db.prepare(`UPDATE sessions SET data=?, updated_at=datetime('now') WHERE id=?`).run(dataStr, id);
  } else {
    db.prepare(`INSERT INTO sessions (id, player_id, data) VALUES (?, ?, ?)`).run(id, playerId, dataStr);
  }
  return getSession(id);
}

function deleteSession(id) {
  if (!id) return false;
  const db = getDb();
  const result = db.prepare(`DELETE FROM sessions WHERE id = ?`).run(id);
  return result.changes > 0;
}

// ─── Settings ───

function getSettings() {
  const db = getDb();
  const rows = db.prepare(`SELECT * FROM settings`).all();
  const obj = {};
  for (const r of rows) obj[r.key] = r.value;
  return obj;
}

function setSetting(key, value) {
  const db = getDb();
  db.prepare(`INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)`).run(key, String(value));
}

function getSetting(key) {
  const db = getDb();
  const r = db.prepare(`SELECT value FROM settings WHERE key = ?`).get(key);
  return r ? r.value : null;
}

// ─── Row Converters ───

function rowToPlayer(r) {
  let avail = {};
  try {
    const arr = JSON.parse(r.availability_arr);
    if (Array.isArray(arr)) {
      for (const a of arr) {
        if (!a || !a.day_name) continue;
        if (!avail[a.day_name]) avail[a.day_name] = [];
        avail[a.day_name].push({ start: a.start, end: a.end, duration: a.duration });
      }
    }
  } catch (e) {
    // ignore
  }
  // Ensure no empty slots create { day_name: [] }
  for (const k of Object.keys(avail)) {
    if (avail[k].length === 0) delete avail[k];
  }
  // Restore empty availability
  if (Object.keys(avail).length === 0) {
    avail = { isSet: false, days: {} };
  }

  return {
    id: r.id,
    name: r.name,
    level: r.level,
    position: r.position,
    telegram_id: r.telegram_id ? Number(r.telegram_id) : null,
    pin: r.pin,
    sessions: r.sessions || 0,
    hours: r.hours || 0,
    wins: r.wins || 0,
    games: r.games || 0,
    avail_mode: r.avail_mode || 'flex',
    weekly_schedule: null,
    availability: avail,
    availability_temp: (r.availability_temp && r.availability_temp !== 'null') ? JSON.parse(r.availability_temp) : null
  };
}

function rowToMatch(r) {
  let players = [];
  try {
    const arr = JSON.parse(r.players_arr);
    if (Array.isArray(arr)) {
      players = arr.filter(p => p && p.player_id).map(p => ({
        id: p.player_id,
        team: p.team || null,
        score: p.score || null
      }));
    }
  } catch (e) {
    // ignore
  }

  let responses = {};
  try { responses = JSON.parse(r.responses); } catch (e) { /* ignore */ }

  let score = null;
  if (r.score) {
    try { score = JSON.parse(r.score); } catch (e) { /* ignore */ }
  }

  let proposed_teams = null;
  if (r.proposed_teams) {
    try { proposed_teams = JSON.parse(r.proposed_teams); } catch (e) { /* ignore */ }
  }

  return {
    id: r.id,
    status: r.status,
    responses: responses,
    proposed_at: r.proposed_at,
    date: r.date,
    start: r.start,
    end: r.end,
    location: r.location,
    day: r.day,
    score: score,
    proposed_teams: proposed_teams,
    booker_id: r.booker_id || null,
    booker_name: r.booker_name || null,
    players: players
  };
}

function safeJsonParse(str, fallback) {
  try { return JSON.parse(str); } catch (e) { return fallback; }
}

// ─── Player Match Stats (idempotent score tracking) ───

function hasMatchStat(playerId, matchId) {
  const db = getDb();
  const r = db.prepare('SELECT 1 FROM player_match_stats WHERE player_id = ? AND match_id = ?').get(String(playerId), String(matchId));
  return !!r;
}

function addMatchStat(playerId, matchId) {
  const db = getDb();
  db.prepare('INSERT OR IGNORE INTO player_match_stats (player_id, match_id) VALUES (?, ?)').run(String(playerId), String(matchId));
}

// ─── Close (for graceful shutdown) ───
function close() {
  if (db) {
    db.close();
    db = null;
  }
}


// ─── Availability Temp helpers ───
function getPlayerAvailTempWeek(playerId, weekKey) {
  const db = getDb();
  const row = db.prepare("SELECT availability_temp FROM players WHERE id = ?").get(playerId);
  if (!row || !row.availability_temp) return null;
  try {
    const temp = JSON.parse(row.availability_temp);
    return temp[weekKey] || null;
  } catch(e) { return null; }
}

module.exports = {
  getDb,
  close,
  getPlayerAvailTempWeek,
  getPlayers,
  getPlayer,
  getPlayerByTelegram,
  addPlayer,
  updatePlayer,
  deletePlayer,
  getMatches,
  getMatch,
  addMatch,
  updateMatch,
  deleteMatch,
  getSessions,
  getSession,
  setSession,
  deleteSession,
  getSettings,
  setSetting,
  getSetting,
  hasMatchStat,
  addMatchStat
};