import express from 'express';
import http from 'http';
import cors from 'cors';
import { Server as SocketIOServer } from 'socket.io';
import path from 'path';
import { fileURLToPath } from 'url';
import axios from 'axios';
import {
  searchUniversal,
  getSong,
  getAlbum,
  getPlaylist,
  getLyrics
} from './jiosaavn.js';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

const app = express();
app.use(cors());
app.use(express.json());

// Health check endpoint
app.get('/healthz', (req, res) => res.send('OK'));

// Room model:
// {
//   id, name, hostId,
//   users: Map<socketId, { name, role: 'host'|'cohost'|'member', muted?: boolean }>
//   track: { url, title, meta, kind, thumb? },
//   isPlaying, anchor, anchorAt,
//   queue: Array<track>
// }
const rooms = new Map();

function ensureRoom(roomId) {
  if (!rooms.has(roomId)) {
    rooms.set(roomId, {
      id: roomId,
      name: null,
      hostId: null,
      users: new Map(),
      track: null,
      isPlaying: false,
      anchor: 0,
      anchorAt: 0,
      queue: []
    });
  }
  return rooms.get(roomId);
}

function currentState(room) {
  return {
    track: room.track,
    isPlaying: room.isPlaying,
    anchor: room.anchor,
    anchorAt: room.anchorAt,
    queue: room.queue
  };
}

function membersPayload(room) {
  return [...room.users.entries()].map(([id, u]) => ({
    id,
    name: u.name || 'Guest',
    role: u.role || 'member',
    muted: !!u.muted,
    isHost: id === room.hostId
  }));
}

function broadcastMembers(roomId) {
  const room = rooms.get(roomId);
  if (!room) return;
  const members = membersPayload(room);
  io.to(roomId).emit('members', { members, roomName: room.name || room.id });
}

function requireHostOrCohost(room, socketId) {
  const u = room.users.get(socketId);
  return (socketId === room.hostId) || (u && (u.role === 'cohost'));
}

function normalizeThumb(meta) {
  const candidates = [
    meta?.image,
    meta?.thumbnail,
    meta?.song_image,
    meta?.album_image,
    meta?.image_url,
    meta?.images?.[0],
    meta?.images?.medium,
    meta?.images?.cover,
    meta?.thumb
  ].filter(Boolean);
  return candidates[0] || null;
}

function findUserByName(room, targetNameRaw) {
  if (!targetNameRaw) return null;
  const targetName = String(targetNameRaw).replace(/^@/, '').trim().toLowerCase();
  // Prefer exact match, else startsWith, else includes
  let candidate = null;
  for (const [id, u] of room.users.entries()) {
    const n = (u.name || '').toLowerCase();
    if (n === targetName) return { id, u };
    if (!candidate && n.startsWith(targetName)) candidate = { id, u };
  }
  if (candidate) return candidate;
  for (const [id, u] of room.users.entries()) {
    const n = (u.name || '').toLowerCase();
    if (n.includes(targetName)) return { id, u };
  }
  return null;
}

// ---------- API endpoints (JioSaavn proxy) ----------
app.get('/api/result', async (req, res) => {
  try {
    const q = req.query.q || '';
    const data = await searchUniversal(q);
    res.json(data);
  } catch (e) {
    res.status(500).json({ error: e.message });
  }
});

app.get('/api/song', async (req, res) => {
  try {
    const q = req.query.q || '';
    const data = await getSong(q);
    res.json(data);
  } catch (e) {
    res.status(500).json({ error: e.message });
  }
});

app.get('/api/album', async (req, res) => {
  try {
    const q = req.query.q || '';
    const data = await getAlbum(q);
    res.json(data);
  } catch (e) {
    res.status(500).json({ error: e.message });
  }
});

app.get('/api/playlist', async (req, res) => {
  try {
    const q = req.query.q || '';
    const data = await getPlaylist(q);
    res.json(data);
  } catch (e) {
    res.status(500).json({ error: e.message });
  }
});

app.get('/api/lyrics', async (req, res) => {
  try {
    const q = req.query.q || '';
    const data = await getLyrics(q);
    res.json(data);
  } catch (e) {
    res.status(500).json({ error: e.message });
  }
});

// ---------- YouTube search (requires YT_API_KEY env) ----------
app.get('/api/ytsearch', async (req, res) => {
  try {
    const key = process.env.YT_API_KEY;
    if (!key) return res.status(501).json({ error: 'YouTube search unavailable: set YT_API_KEY env' });
    const q = req.query.q || '';
    const resp = await axios.get('https://www.googleapis.com/youtube/v3/search', {
      params: { key, q, part: 'snippet', type: 'video', maxResults: 12 },
      timeout: 10000
    });
    const items = (resp.data.items || []).map(it => ({
      videoId: it.id?.videoId,
      title: it.snippet?.title,
      channelTitle: it.snippet?.channelTitle,
      thumb: it.snippet?.thumbnails?.medium?.url || it.snippet?.thumbnails?.default?.url
    })).filter(x => x.videoId);
    res.json({ items });
  } catch (e) {
    res.status(500).json({ error: e.message });
  }
});

// Active rooms for lobby
app.get('/api/rooms', (_req, res) => {
  const data = [...rooms.values()]
    .filter(r => r.users.size > 0)
    .map(r => ({
      id: r.id,
      name: r.name || r.id,
      members: r.users.size,
      isPlaying: r.isPlaying
    }));
  res.json({ rooms: data });
});

app.get('/api/ping', (_req, res) => res.json({ ok: true }));

// Serve frontend build
const clientDir = path.resolve(__dirname, '../client/dist');
app.use(express.static(clientDir));
app.get('*', (_req, res) => res.sendFile(path.join(clientDir, 'index.html')));

// ---------- Socket.IO ----------
const server = http.createServer(app);
const io = new SocketIOServer(server, {
  cors: { origin: '*', methods: ['GET', 'POST'] }
});

io.on('connection', (socket) => {
  let joinedRoom = null;

  socket.on('join_room', ({ roomId, name, asHost = false, roomName = null }, ack) => {
    const room = ensureRoom(roomId);

    if (asHost || !room.hostId) room.hostId = socket.id;
    if (!room.name && roomName) room.name = String(roomName).trim().slice(0, 60) || null;

    const role = socket.id === room.hostId ? 'host' : 'member';
    const cleanName = String(name || 'Guest').slice(0, 40);
    room.users.set(socket.id, { name: cleanName, role });

    socket.join(roomId);
    joinedRoom = roomId;

    ack?.({
      roomId,
      isHost: socket.id === room.hostId,
      state: currentState(room),
      roomName: room.name || room.id
    });

    io.to(roomId).emit('system', { text: `System: ${cleanName} has joined the chat` });
    broadcastMembers(roomId);
  });

  socket.on('rename', ({ roomId, newName }) => {
    const room = rooms.get(roomId);
    if (!room) return;
    const u = room.users.get(socket.id);
    if (!u) return;
    u.name = String(newName || 'Guest').slice(0, 40);
    broadcastMembers(roomId);
  });

  socket.on('chat_message', ({ roomId, name, text }) => {
    const room = rooms.get(roomId);
    if (!room) return;
    const u = room.users.get(socket.id);
    if (!u) return;
    if (u.muted) {
      socket.emit('system', { text: 'System: You are muted by the host' });
      return;
    }
    socket.to(roomId).emit('chat_message', { name, text, at: Date.now() });
  });

  // /play request
  socket.on('song_request', ({ roomId, requester, query }) => {
    const room = rooms.get(roomId);
    if (!room) return;
    const payload = { requester, query, at: Date.now(), requestId: `${Date.now()}_${Math.random().toString(36).slice(2)}` };
    for (const [id, usr] of room.users.entries()) {
      if (id === room.hostId || usr.role === 'cohost') io.to(id).emit('song_request', payload);
    }
    io.to(roomId).emit('system', { text: `System: ${requester} requested /play ${query}` });
  });

  // Host handles request action
  socket.on('song_request_action', ({ roomId, action, track }) => {
    const room = rooms.get(roomId);
    if (!room) return;
    if (!requireHostOrCohost(room, socket.id)) return;
    if ((action === 'accept' || action === 'queue') && track) {
      const t = {
        url: track.url,
        title: track.title || track.url,
        meta: track.meta || {},
        kind: track.kind || 'audio',
        thumb: track.thumb || normalizeThumb(track.meta || {})
      };
      if (action === 'accept') {
        room.track = t;
        room.isPlaying = false;
        room.anchor = 0;
        room.anchorAt = Date.now();
        io.to(roomId).emit('set_track', { track: room.track });
        io.to(roomId).emit('pause', { anchor: 0, anchorAt: room.anchorAt });
        io.to(roomId).emit('system', { text: `System: Now playing ${room.track.title}` });
      } else {
        room.queue.push(t);
        io.to(roomId).emit('queue_update', { queue: room.queue });
        io.to(roomId).emit('system', { text: `System: Queued ${t.title}` });
      }
    }
  });

  // Host/cohost controls
  socket.on('set_track', ({ roomId, track }) => {
    const room = rooms.get(roomId);
    if (!room || !requireHostOrCohost(room, socket.id)) return;
    const thumb = track.thumb || normalizeThumb(track.meta || {});
    room.track = { ...track, thumb };
    room.isPlaying = false;
    room.anchor = 0;
    room.anchorAt = Date.now();
    io.to(roomId).emit('set_track', { track: room.track });
    io.to(roomId).emit('pause', { anchor: 0, anchorAt: room.anchorAt });
    io.to(roomId).emit('system', { text: `System: Selected ${room.track.title || room.track.url}` });
  });

  socket.on('play', ({ roomId }) => {
    const room = rooms.get(roomId);
    if (!room || !requireHostOrCohost(room, socket.id)) return;
    room.isPlaying = true;
    room.anchorAt = Date.now();
    io.to(roomId).emit('play', { anchor: room.anchor, anchorAt: room.anchorAt });
  });

  socket.on('pause', ({ roomId }) => {
    const room = rooms.get(roomId);
    if (!room || !requireHostOrCohost(room, socket.id)) return;
    const elapsed = Math.max(0, Date.now() - room.anchorAt) / 1000;
    if (room.isPlaying) room.anchor += elapsed;
    room.isPlaying = false;
    room.anchorAt = Date.now();
    io.to(roomId).emit('pause', { anchor: room.anchor, anchorAt: room.anchorAt });
  });

  socket.on('seek', ({ roomId, to }) => {
    const room = rooms.get(roomId);
    if (!room || !requireHostOrCohost(room, socket.id)) return;
    room.anchor = to;
    room.anchorAt = Date.now();
    io.to(roomId).emit('seek', { anchor: room.anchor, anchorAt: room.anchorAt, isPlaying: room.isPlaying });
  });

  // Ended -> auto next
  socket.on('ended', ({ roomId }) => {
    const room = rooms.get(roomId);
    if (!room || !requireHostOrCohost(room, socket.id)) return;
    const next = room.queue.shift();
    if (next) {
      const thumb = next.thumb || normalizeThumb(next.meta || {});
      room.track = { ...next, thumb };
      room.isPlaying = false;
      room.anchor = 0;
      room.anchorAt = Date.now();
      io.to(roomId).emit('set_track', { track: room.track });
      io.to(roomId).emit('pause', { anchor: 0, anchorAt: room.anchorAt });
      io.to(roomId).emit('queue_update', { queue: room.queue });
      io.to(roomId).emit('system', { text: `System: Now playing ${room.track.title}` });
    } else {
      io.to(roomId).emit('system', { text: 'System: Queue ended' });
    }
  });

  // Admin commands
  socket.on('admin_command', ({ roomId, cmd, targetName }) => {
    const room = rooms.get(roomId);
    if (!room) return;
    const actor = room.users.get(socket.id);
    if (!actor || !(socket.id === room.hostId || actor.role === 'cohost')) return;

    const found = findUserByName(room, targetName);
    if (!found) {
      io.to(socket.id).emit('system', { text: `System: User @${targetName} not found` });
      return;
    }

    if (cmd === 'kick') {
      const { id } = found;
      io.to(id).emit('system', { text: 'System: You were kicked by the host' });
      io.sockets.sockets.get(id)?.leave(roomId);
      room.users.delete(id);
      io.to(roomId).emit('system', { text: `System: ${found.u.name} was kicked` });
      broadcastMembers(roomId);
    } else if (cmd === 'promote') {
      found.u.role = 'cohost';
      io.to(roomId).emit('system', { text: `System: ${found.u.name} was promoted to co-host` });
      broadcastMembers(roomId);
    } else if (cmd === 'mute') {
      found.u.muted = true;
      io.to(roomId).emit('system', { text: `System: ${found.u.name} was muted` });
      broadcastMembers(roomId);
    }
  });

  socket.on('sync_request', ({ roomId }, ack) => {
    const room = rooms.get(roomId);
    if (!room) return;
    ack?.(currentState(room));
  });

  socket.on('disconnect', () => {
    if (!joinedRoom) return;
    const room = rooms.get(joinedRoom);
    if (!room) return;
    const leftUser = room.users.get(socket.id);
    room.users.delete(socket.id);
    if (socket.id === room.hostId) {
      const nextHost = [...room.users.keys()][0];
      room.hostId = nextHost || null;
      if (room.hostId) {
        const u = room.users.get(room.hostId);
        if (u) u.role = 'host';
      }
      io.to(joinedRoom).emit('host_changed', { hostId: room.hostId });
    }
    if (leftUser) {
      const nm = leftUser.name || 'User';
      io.to(joinedRoom).emit('system', { text: `System: ${nm} has left the chat` });
    }
    if (room.users.size === 0) {
      rooms.delete(joinedRoom);
    } else {
      broadcastMembers(joinedRoom);
    }
  });
});

const PORT = process.env.PORT || 3000;
server.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});