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
}

// HandleCreateSession creates a new user session and returns the auth token.
func (s *Handlers) HandleCreateSession() 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)
	}
}

// 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)
	}
}

// HandleSendCommand handles all C2S commands via POST /messages.
// The "command" field dispatches to the appropriate logic.
func (s *Handlers) HandleSendCommand() http.HandlerFunc {
	type request struct {
		Command string      `json:"command"`
		To      string      `json:"to"`
		Params  []string    `json:"params,omitempty"`
		Body    interface{} `json:"body,omitempty"`
	}
	return func(w http.ResponseWriter, r *http.Request) {
		uid, nick, 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.Command = strings.ToUpper(strings.TrimSpace(req.Command))
		req.To = strings.TrimSpace(req.To)

		// Helper to extract body as string lines.
		bodyLines := func() []string {
			switch v := req.Body.(type) {
			case []interface{}:
				lines := make([]string, 0, len(v))
				for _, item := range v {
					if s, ok := item.(string); ok {
						lines = append(lines, s)
					}
				}
				return lines
			case []string:
				return v
			default:
				return nil
			}
		}

		switch req.Command {
		case "PRIVMSG", "NOTICE":
			if req.To == "" {
				s.respondJSON(w, r, map[string]string{"error": "to field required"}, http.StatusBadRequest)
				return
			}
			lines := bodyLines()
			if len(lines) == 0 {
				s.respondJSON(w, r, map[string]string{"error": "body required"}, http.StatusBadRequest)
				return
			}
			content := strings.Join(lines, "\n")

			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, 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, 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)
			}

		case "JOIN":
			if req.To == "" {
				s.respondJSON(w, r, map[string]string{"error": "to field required"}, http.StatusBadRequest)
				return
			}
			channel := req.To
			if !strings.HasPrefix(channel, "#") {
				channel = "#" + channel
			}
			chID, err := s.params.Database.GetOrCreateChannel(r.Context(), 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": channel}, http.StatusOK)

		case "PART":
			if req.To == "" {
				s.respondJSON(w, r, map[string]string{"error": "to field required"}, http.StatusBadRequest)
				return
			}
			channel := req.To
			if !strings.HasPrefix(channel, "#") {
				channel = "#" + channel
			}
			var chID int64
			err := s.params.Database.GetDB().QueryRowContext(r.Context(),
				"SELECT id FROM channels WHERE name = ?", channel).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": channel}, http.StatusOK)

		case "NICK":
			lines := bodyLines()
			if len(lines) == 0 {
				s.respondJSON(w, r, map[string]string{"error": "body required (new nick)"}, http.StatusBadRequest)
				return
			}
			newNick := strings.TrimSpace(lines[0])
			if newNick == "" || len(newNick) > 32 {
				s.respondJSON(w, r, map[string]string{"error": "nick must be 1-32 characters"}, http.StatusBadRequest)
				return
			}
			if err := s.params.Database.ChangeNick(r.Context(), uid, newNick); err != nil {
				if strings.Contains(err.Error(), "UNIQUE") {
					s.respondJSON(w, r, map[string]string{"error": "nick already in use"}, http.StatusConflict)
					return
				}
				s.log.Error("change nick failed", "error", err)
				s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
				return
			}
			s.respondJSON(w, r, map[string]string{"status": "ok", "nick": newNick}, http.StatusOK)

		case "TOPIC":
			if req.To == "" {
				s.respondJSON(w, r, map[string]string{"error": "to field required"}, http.StatusBadRequest)
				return
			}
			lines := bodyLines()
			if len(lines) == 0 {
				s.respondJSON(w, r, map[string]string{"error": "body required (topic text)"}, http.StatusBadRequest)
				return
			}
			topic := strings.Join(lines, " ")
			channel := req.To
			if !strings.HasPrefix(channel, "#") {
				channel = "#" + channel
			}
			if err := s.params.Database.SetTopic(r.Context(), channel, uid, topic); err != nil {
				s.log.Error("set topic failed", "error", err)
				s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
				return
			}
			s.respondJSON(w, r, map[string]string{"status": "ok", "topic": topic}, http.StatusOK)

		case "PING":
			s.respondJSON(w, r, map[string]string{"command": "PONG", "from": s.params.Config.ServerName}, http.StatusOK)

		default:
			_ = nick // suppress unused warning
			s.respondJSON(w, r, map[string]string{"error": "unknown command: " + req.Command}, http.StatusBadRequest)
		}
	}
}

// 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)
	}
}