package handlers

import (
	"database/sql"
	"encoding/json"
	"net/http"
	"strconv"
	"strings"

	"git.eeqj.de/sneak/chat/internal/db"
	"github.com/go-chi/chi"
)

// authUser extracts the user from the Authorization header (Bearer token).
func (s *Handlers) authUser(r *http.Request) (int64, string, error) {
	auth := r.Header.Get("Authorization")
	if !strings.HasPrefix(auth, "Bearer ") {
		return 0, "", sql.ErrNoRows
	}
	token := strings.TrimPrefix(auth, "Bearer ")
	return s.params.Database.GetUserByToken(r.Context(), token)
}

func (s *Handlers) requireAuth(w http.ResponseWriter, r *http.Request) (int64, string, bool) {
	uid, nick, err := s.authUser(r)
	if err != nil {
		s.respondJSON(w, r, map[string]string{"error": "unauthorized"}, http.StatusUnauthorized)
		return 0, "", false
	}
	return uid, nick, true
}

// HandleRegister creates a new user and returns the auth token.
func (s *Handlers) HandleRegister() http.HandlerFunc {
	type request struct {
		Nick string `json:"nick"`
	}
	type response struct {
		ID    int64  `json:"id"`
		Nick  string `json:"nick"`
		Token string `json:"token"`
	}
	return func(w http.ResponseWriter, r *http.Request) {
		var req request
		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
			s.respondJSON(w, r, map[string]string{"error": "invalid request"}, http.StatusBadRequest)
			return
		}
		req.Nick = strings.TrimSpace(req.Nick)
		if req.Nick == "" || len(req.Nick) > 32 {
			s.respondJSON(w, r, map[string]string{"error": "nick must be 1-32 characters"}, http.StatusBadRequest)
			return
		}
		id, token, err := s.params.Database.CreateUser(r.Context(), req.Nick)
		if err != nil {
			if strings.Contains(err.Error(), "UNIQUE") {
				s.respondJSON(w, r, map[string]string{"error": "nick already taken"}, http.StatusConflict)
				return
			}
			s.log.Error("create user failed", "error", err)
			s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
			return
		}
		s.respondJSON(w, r, &response{ID: id, Nick: req.Nick, Token: token}, http.StatusCreated)
	}
}

// HandleState returns the current user's info and joined channels.
func (s *Handlers) HandleState() http.HandlerFunc {
	type response struct {
		ID       int64            `json:"id"`
		Nick     string           `json:"nick"`
		Channels []db.ChannelInfo `json:"channels"`
	}
	return func(w http.ResponseWriter, r *http.Request) {
		uid, nick, ok := s.requireAuth(w, r)
		if !ok {
			return
		}
		channels, err := s.params.Database.ListChannels(r.Context(), uid)
		if err != nil {
			s.log.Error("list channels failed", "error", err)
			s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
			return
		}
		s.respondJSON(w, r, &response{ID: uid, Nick: nick, Channels: channels}, http.StatusOK)
	}
}

// HandleListAllChannels returns all channels on the server.
func (s *Handlers) HandleListAllChannels() http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		_, _, ok := s.requireAuth(w, r)
		if !ok {
			return
		}
		channels, err := s.params.Database.ListAllChannels(r.Context())
		if err != nil {
			s.log.Error("list all channels failed", "error", err)
			s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
			return
		}
		s.respondJSON(w, r, channels, http.StatusOK)
	}
}

// HandleJoinChannel joins a channel (creates it if needed).
func (s *Handlers) HandleJoinChannel() http.HandlerFunc {
	type request struct {
		Channel string `json:"channel"`
	}
	return func(w http.ResponseWriter, r *http.Request) {
		uid, _, ok := s.requireAuth(w, r)
		if !ok {
			return
		}
		var req request
		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
			s.respondJSON(w, r, map[string]string{"error": "invalid request"}, http.StatusBadRequest)
			return
		}
		req.Channel = strings.TrimSpace(req.Channel)
		if req.Channel == "" {
			s.respondJSON(w, r, map[string]string{"error": "channel name required"}, http.StatusBadRequest)
			return
		}
		if !strings.HasPrefix(req.Channel, "#") {
			req.Channel = "#" + req.Channel
		}
		chID, err := s.params.Database.GetOrCreateChannel(r.Context(), req.Channel)
		if err != nil {
			s.log.Error("get/create channel failed", "error", err)
			s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
			return
		}
		if err := s.params.Database.JoinChannel(r.Context(), chID, uid); err != nil {
			s.log.Error("join channel failed", "error", err)
			s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
			return
		}
		s.respondJSON(w, r, map[string]string{"status": "joined", "channel": req.Channel}, http.StatusOK)
	}
}

// HandlePartChannel leaves a channel.
func (s *Handlers) HandlePartChannel() http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		uid, _, ok := s.requireAuth(w, r)
		if !ok {
			return
		}
		name := "#" + chi.URLParam(r, "channel")
		var chID int64
		err := s.params.Database.GetDB().QueryRowContext(r.Context(),
			"SELECT id FROM channels WHERE name = ?", name).Scan(&chID)
		if err != nil {
			s.respondJSON(w, r, map[string]string{"error": "channel not found"}, http.StatusNotFound)
			return
		}
		if err := s.params.Database.PartChannel(r.Context(), chID, uid); err != nil {
			s.log.Error("part channel failed", "error", err)
			s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
			return
		}
		s.respondJSON(w, r, map[string]string{"status": "parted", "channel": name}, http.StatusOK)
	}
}

// HandleChannelMembers returns members of a channel.
func (s *Handlers) HandleChannelMembers() http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		_, _, ok := s.requireAuth(w, r)
		if !ok {
			return
		}
		name := "#" + chi.URLParam(r, "channel")
		var chID int64
		err := s.params.Database.GetDB().QueryRowContext(r.Context(),
			"SELECT id FROM channels WHERE name = ?", name).Scan(&chID)
		if err != nil {
			s.respondJSON(w, r, map[string]string{"error": "channel not found"}, http.StatusNotFound)
			return
		}
		members, err := s.params.Database.ChannelMembers(r.Context(), chID)
		if err != nil {
			s.log.Error("channel members failed", "error", err)
			s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
			return
		}
		s.respondJSON(w, r, members, http.StatusOK)
	}
}

// HandleGetMessages returns all new messages (channel + DM) for the user via long-polling.
// This is the single unified message stream — replaces separate channel/DM/poll endpoints.
func (s *Handlers) HandleGetMessages() http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		uid, _, ok := s.requireAuth(w, r)
		if !ok {
			return
		}
		afterID, _ := strconv.ParseInt(r.URL.Query().Get("after"), 10, 64)
		limit, _ := strconv.Atoi(r.URL.Query().Get("limit"))
		msgs, err := s.params.Database.PollMessages(r.Context(), uid, afterID, limit)
		if err != nil {
			s.log.Error("get messages failed", "error", err)
			s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
			return
		}
		s.respondJSON(w, r, msgs, http.StatusOK)
	}
}

// HandleSendMessage sends a message to a channel or user.
// The "to" field determines the target: "#channel" for channels, "nick" for DMs.
func (s *Handlers) HandleSendMessage() http.HandlerFunc {
	type request struct {
		To      string `json:"to"`
		Content string `json:"content"`
	}
	return func(w http.ResponseWriter, r *http.Request) {
		uid, _, ok := s.requireAuth(w, r)
		if !ok {
			return
		}
		var req request
		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
			s.respondJSON(w, r, map[string]string{"error": "invalid request"}, http.StatusBadRequest)
			return
		}
		if strings.TrimSpace(req.Content) == "" {
			s.respondJSON(w, r, map[string]string{"error": "content required"}, http.StatusBadRequest)
			return
		}
		req.To = strings.TrimSpace(req.To)
		if req.To == "" {
			s.respondJSON(w, r, map[string]string{"error": "to field required"}, http.StatusBadRequest)
			return
		}

		if strings.HasPrefix(req.To, "#") {
			// Channel message
			var chID int64
			err := s.params.Database.GetDB().QueryRowContext(r.Context(),
				"SELECT id FROM channels WHERE name = ?", req.To).Scan(&chID)
			if err != nil {
				s.respondJSON(w, r, map[string]string{"error": "channel not found"}, http.StatusNotFound)
				return
			}
			msgID, err := s.params.Database.SendMessage(r.Context(), chID, uid, req.Content)
			if err != nil {
				s.log.Error("send message failed", "error", err)
				s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
				return
			}
			s.respondJSON(w, r, map[string]any{"id": msgID, "status": "sent"}, http.StatusCreated)
		} else {
			// DM
			targetID, err := s.params.Database.GetUserByNick(r.Context(), req.To)
			if err != nil {
				s.respondJSON(w, r, map[string]string{"error": "user not found"}, http.StatusNotFound)
				return
			}
			msgID, err := s.params.Database.SendDM(r.Context(), uid, targetID, req.Content)
			if err != nil {
				s.log.Error("send dm failed", "error", err)
				s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
				return
			}
			s.respondJSON(w, r, map[string]any{"id": msgID, "status": "sent"}, http.StatusCreated)
		}
	}
}

// HandleGetHistory returns message history for a specific target (channel or DM).
func (s *Handlers) HandleGetHistory() http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		uid, _, ok := s.requireAuth(w, r)
		if !ok {
			return
		}
		target := r.URL.Query().Get("target")
		if target == "" {
			s.respondJSON(w, r, map[string]string{"error": "target required"}, http.StatusBadRequest)
			return
		}
		beforeID, _ := strconv.ParseInt(r.URL.Query().Get("before"), 10, 64)
		limit, _ := strconv.Atoi(r.URL.Query().Get("limit"))
		if limit <= 0 {
			limit = 50
		}

		if strings.HasPrefix(target, "#") {
			// Channel history
			var chID int64
			err := s.params.Database.GetDB().QueryRowContext(r.Context(),
				"SELECT id FROM channels WHERE name = ?", target).Scan(&chID)
			if err != nil {
				s.respondJSON(w, r, map[string]string{"error": "channel not found"}, http.StatusNotFound)
				return
			}
			msgs, err := s.params.Database.GetMessagesBefore(r.Context(), chID, beforeID, limit)
			if err != nil {
				s.log.Error("get history failed", "error", err)
				s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
				return
			}
			s.respondJSON(w, r, msgs, http.StatusOK)
		} else {
			// DM history
			targetID, err := s.params.Database.GetUserByNick(r.Context(), target)
			if err != nil {
				s.respondJSON(w, r, map[string]string{"error": "user not found"}, http.StatusNotFound)
				return
			}
			msgs, err := s.params.Database.GetDMsBefore(r.Context(), uid, targetID, beforeID, limit)
			if err != nil {
				s.log.Error("get dm history failed", "error", err)
				s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
				return
			}
			s.respondJSON(w, r, msgs, http.StatusOK)
		}
	}
}

// HandleServerInfo returns server metadata (MOTD, name).
func (s *Handlers) HandleServerInfo() http.HandlerFunc {
	type response struct {
		Name string `json:"name"`
		MOTD string `json:"motd"`
	}
	return func(w http.ResponseWriter, r *http.Request) {
		s.respondJSON(w, r, &response{
			Name: s.params.Config.ServerName,
			MOTD: s.params.Config.MOTD,
		}, http.StatusOK)
	}
}