package httpapi_test

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"net/http"
	"net/http/httptest"
	"testing"
	"time"

	"watch-party-backend/internal/core/episode"
	"watch-party-backend/internal/danime"
	httpapi "watch-party-backend/internal/http"

	"github.com/gin-gonic/gin"
)

// ---- fake service implementing episode.UseCases ----

type fakeSvc struct {
	cur        episode.Episode
	getErr     error
	setCur     episode.Episode
	setErr     error
	moveRes    episode.MoveResult
	moveErr    error
	listRes    []episode.Episode
	listErr    error
	deleteErr  error
	createRes  episode.Episode
	createErr  error
	lastSetID  int64
	lastTime   string
	lastMove   []int64
	lastDelID  int64
	lastCreate episode.NewShowInput
}

func (f *fakeSvc) GetCurrent(ctx context.Context) (episode.Episode, error) {
	return f.cur, f.getErr
}
func (f *fakeSvc) SetCurrent(ctx context.Context, id int64, start string) (episode.Episode, error) {
	f.lastSetID, f.lastTime = id, start
	return f.setCur, f.setErr
}
func (f *fakeSvc) MoveToArchive(ctx context.Context, ids []int64) (episode.MoveResult, error) {
	f.lastMove = append([]int64(nil), ids...)
	return f.moveRes, f.moveErr
}
func (f *fakeSvc) ListAll(ctx context.Context) ([]episode.Episode, error) {
	if f.listRes == nil && f.listErr == nil {
		return []episode.Episode{{Id: 10, EpTitle: "X"}}, nil
	}
	return f.listRes, f.listErr
}
func (f *fakeSvc) Delete(ctx context.Context, id int64) error {
	f.lastDelID = id
	return f.deleteErr
}
func (f *fakeSvc) Create(ctx context.Context, in episode.NewShowInput) (episode.Episode, error) {
	f.lastCreate = in
	return f.createRes, f.createErr
}

// ---- helpers ----

func newRouterWithSvc(svc episode.UseCases) *gin.Engine {
	gin.SetMode(gin.TestMode)
	return httpapi.NewRouter(svc)
}

func doJSON(t *testing.T, r *gin.Engine, method, path string, body any) *httptest.ResponseRecorder {
	t.Helper()
	var buf bytes.Buffer
	if body != nil {
		if err := json.NewEncoder(&buf).Encode(body); err != nil {
			t.Fatalf("encode body: %v", err)
		}
	}
	req := httptest.NewRequest(method, path, &buf)
	req.Header.Set("Content-Type", "application/json")
	w := httptest.NewRecorder()
	r.ServeHTTP(w, req)
	return w
}

// ---- tests ----

func TestHealthz_OK(t *testing.T) {
	r := newRouterWithSvc(&fakeSvc{})
	w := httptest.NewRecorder()
	req := httptest.NewRequest(http.MethodGet, "/healthz", nil)
	r.ServeHTTP(w, req)
	if w.Code != http.StatusOK {
		t.Fatalf("got %d", w.Code)
	}
}

func TestGetCurrent_V1_OK(t *testing.T) {
	now := time.Now().UTC()
	svc := &fakeSvc{
		cur: episode.Episode{
			EpNum:          7,
			EpTitle:        "Lucky",
			SeasonName:     "S2",
			StartTime:      "18:30:00",
			PlaybackLength: "00:24:00",
			DateCreated:    now,
		},
	}
	r := newRouterWithSvc(svc)

	w := httptest.NewRecorder()
	req := httptest.NewRequest(http.MethodGet, "/api/v1/current", nil)
	r.ServeHTTP(w, req)
	if w.Code != http.StatusOK {
		t.Fatalf("got %d", w.Code)
	}
	var got episode.Episode
	if err := json.Unmarshal(w.Body.Bytes(), &got); err != nil {
		t.Fatalf("json: %v", err)
	}
	if got.EpNum != 7 || got.EpTitle != "Lucky" {
		t.Fatalf("unexpected %+v", got)
	}
}

func TestPostCurrent_BadPayload(t *testing.T) {
	r := newRouterWithSvc(&fakeSvc{})
	// missing fields
	w := doJSON(t, r, http.MethodPost, "/api/v1/current", map[string]any{"id": 1})
	if w.Code != http.StatusBadRequest {
		t.Fatalf("expected 400, got %d", w.Code)
	}
}

func TestPostCurrent_BadTime(t *testing.T) {
	svc := &fakeSvc{setErr: episode.ErrInvalidStartTime}
	r := newRouterWithSvc(svc)
	w := doJSON(t, r, http.MethodPost, "/api/v1/current", map[string]any{
		"id": 42, "start_time": "7:0:0",
	})
	if w.Code != http.StatusBadRequest {
		t.Fatalf("expected 400, got %d; body=%s", w.Code, w.Body.String())
	}
}

func TestPostCurrent_OK(t *testing.T) {
	want := episode.Episode{EpNum: 42, EpTitle: "Answer", StartTime: "21:07:05"}
	svc := &fakeSvc{setCur: want}
	r := newRouterWithSvc(svc)
	w := doJSON(t, r, http.MethodPost, "/api/v1/current", map[string]any{
		"id": 42, "start_time": "21:07:05",
	})
	if w.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d; body=%s", w.Code, w.Body.String())
	}
	var got episode.Episode
	if err := json.Unmarshal(w.Body.Bytes(), &got); err != nil {
		t.Fatalf("json: %v", err)
	}
	if got.EpNum != want.EpNum || got.StartTime != want.StartTime {
		t.Fatalf("unexpected %+v", got)
	}
	if svc.lastSetID != 42 || svc.lastTime != "21:07:05" {
		t.Fatalf("service not called as expected: id=%d time=%s", svc.lastSetID, svc.lastTime)
	}
}

func TestPostArchive_Empty(t *testing.T) {
	svc := &fakeSvc{moveErr: episode.ErrEmptyIDs}
	r := newRouterWithSvc(svc)
	w := doJSON(t, r, http.MethodPost, "/api/v1/archive", map[string]any{})
	if w.Code != http.StatusBadRequest {
		t.Fatalf("expected 400, got %d; body=%s", w.Code, w.Body.String())
	}
}

func TestPostArchive_SingleAndMultiple_OK(t *testing.T) {
	svc := &fakeSvc{
		moveRes: episode.MoveResult{
			MovedIDs:   []int64{1, 2},
			DeletedIDs: []int64{1, 2},
			SkippedIDs: []int64{999},
		},
	}
	r := newRouterWithSvc(svc)

	// single
	w1 := doJSON(t, r, http.MethodPost, "/api/v1/archive", map[string]any{"id": 1})
	if w1.Code != http.StatusOK {
		t.Fatalf("got %d: %s", w1.Code, w1.Body.String())
	}
	// multiple
	w2 := doJSON(t, r, http.MethodPost, "/api/v1/archive", map[string]any{"ids": []int64{1, 2, 1}})
	if w2.Code != http.StatusOK {
		t.Fatalf("got %d: %s", w2.Code, w2.Body.String())
	}
	// check the lastMove captured by fake
	if len(svc.lastMove) != 3 || svc.lastMove[0] != 1 || svc.lastMove[1] != 2 {
		t.Fatalf("unexpected service ids: %+v", svc.lastMove)
	}
	// basic JSON fields present
	var body map[string]any
	if err := json.Unmarshal(w2.Body.Bytes(), &body); err != nil {
		t.Fatalf("json: %v", err)
	}
	if body["inserted"] == nil || body["deleted"] == nil {
		t.Fatalf("missing counters in response: %+v", body)
	}
}

func TestPostShows_BadPayload(t *testing.T) {
	r := newRouterWithSvc(&fakeSvc{})
	w := doJSON(t, r, http.MethodPost, "/api/v1/shows", map[string]any{"ep_title": "Pilot"})
	if w.Code != http.StatusBadRequest {
		t.Fatalf("expected 400, got %d", w.Code)
	}
}

func TestPostShows_ValidationErrors(t *testing.T) {
	tests := []struct {
		name    string
		err     error
		code    int
		payload any
	}{
		{
			name: "bad start",
			err:  episode.ErrInvalidStartTime,
			code: http.StatusBadRequest,
			payload: map[string]any{
				"ep_num": 1, "ep_title": "Pilot", "season_name": "S1", "start_time": "1:0:0", "playback_length": "00:24:00",
			},
		},
		{
			name: "bad playback",
			err:  episode.ErrInvalidPlayback,
			code: http.StatusBadRequest,
			payload: map[string]any{
				"ep_num": 1, "ep_title": "Pilot", "season_name": "S1", "start_time": "10:00:00", "playback_length": "0:0:0",
			},
		},
		{
			name: "service error",
			err:  errors.New("db down"),
			code: http.StatusInternalServerError,
			payload: map[string]any{
				"ep_num": 1, "ep_title": "Pilot", "season_name": "S1", "start_time": "10:00:00", "playback_length": "00:24:00",
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			svc := &fakeSvc{createErr: tt.err}
			r := newRouterWithSvc(svc)
			w := doJSON(t, r, http.MethodPost, "/api/v1/shows", tt.payload)
			if w.Code != tt.code {
				t.Fatalf("expected %d, got %d body=%s", tt.code, w.Code, w.Body.String())
			}
		})
	}
}

func TestPostShows_OK(t *testing.T) {
	now := time.Now().UTC()
	want := episode.Episode{
		Id:             9,
		EpNum:          1,
		EpTitle:        "Pilot",
		SeasonName:     "S1",
		StartTime:      "10:00:00",
		PlaybackLength: "00:24:00",
		CurrentEp:      false,
		DateCreated:    now,
	}
	svc := &fakeSvc{createRes: want}
	r := newRouterWithSvc(svc)
	w := doJSON(t, r, http.MethodPost, "/api/v1/shows", map[string]any{
		"ep_num": 1, "ep_title": "Pilot", "season_name": "S1", "start_time": "10:00:00", "playback_length": "00:24:00",
	})
	if w.Code != http.StatusCreated {
		t.Fatalf("expected 201, got %d: %s", w.Code, w.Body.String())
	}
	var got episode.Episode
	if err := json.Unmarshal(w.Body.Bytes(), &got); err != nil {
		t.Fatalf("json: %v", err)
	}
	if got.Id != want.Id || got.CurrentEp {
		t.Fatalf("unexpected body: %+v", got)
	}
	if svc.lastCreate.EpTitle != "Pilot" || svc.lastCreate.StartTime != "10:00:00" {
		t.Fatalf("service called with wrong input: %+v", svc.lastCreate)
	}
}

func TestPostShows_DefaultStartTime(t *testing.T) {
	now := time.Now().UTC()
	svc := &fakeSvc{
		createRes: episode.Episode{
			Id:             11,
			EpNum:          2,
			EpTitle:        "No Start",
			SeasonName:     "S2",
			StartTime:      "22:00:00",
			PlaybackLength: "00:24:00",
			DateCreated:    now,
		},
	}
	r := newRouterWithSvc(svc)
	w := doJSON(t, r, http.MethodPost, "/api/v1/shows", map[string]any{
		"ep_num": 2, "ep_title": "No Start", "season_name": "S2", "playback_length": "00:24:00",
	})
	if w.Code != http.StatusCreated {
		t.Fatalf("expected 201, got %d: %s", w.Code, w.Body.String())
	}
	if svc.lastCreate.StartTime != "22:00:00" {
		t.Fatalf("expected default start time, got %s", svc.lastCreate.StartTime)
	}
}

func TestGetDanime_MissingParam(t *testing.T) {
	r := newRouterWithSvc(&fakeSvc{})
	req := httptest.NewRequest(http.MethodGet, "/api/v1/danime", nil)
	w := httptest.NewRecorder()
	r.ServeHTTP(w, req)
	if w.Code != http.StatusBadRequest {
		t.Fatalf("expected 400, got %d", w.Code)
	}
}

func TestGetDanime_Error(t *testing.T) {
	prev := httpapi.FetchDanimeEpisode
	httpapi.FetchDanimeEpisode = func(ctx context.Context, partID string) (*danime.Episode, error) {
		return nil, errors.New("boom")
	}
	defer func() { httpapi.FetchDanimeEpisode = prev }()

	r := newRouterWithSvc(&fakeSvc{})
	req := httptest.NewRequest(http.MethodGet, "/api/v1/danime?part_id=123", nil)
	w := httptest.NewRecorder()
	r.ServeHTTP(w, req)
	if w.Code != http.StatusBadGateway {
		t.Fatalf("expected 502, got %d", w.Code)
	}
}

func TestGetDanime_OK(t *testing.T) {
	prev := httpapi.FetchDanimeEpisode
	httpapi.FetchDanimeEpisode = func(ctx context.Context, partID string) (*danime.Episode, error) {
		return &danime.Episode{
			EpNum:          21,
			EpTitle:        "Title",
			SeasonName:     "Season",
			PlaybackLength: "00:23:50",
		}, nil
	}
	defer func() { httpapi.FetchDanimeEpisode = prev }()

	r := newRouterWithSvc(&fakeSvc{})
	req := httptest.NewRequest(http.MethodGet, "/api/v1/danime?part_id=23863021", nil)
	w := httptest.NewRecorder()
	r.ServeHTTP(w, req)
	if w.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
	}
	var got danime.Episode
	if err := json.Unmarshal(w.Body.Bytes(), &got); err != nil {
		t.Fatalf("json: %v", err)
	}
	if got.EpNum != 21 || got.PlaybackLength != "00:23:50" {
		t.Fatalf("unexpected body: %+v", got)
	}
}

func TestListShows_OK(t *testing.T) {
	svc := &fakeSvc{
		listRes: []episode.Episode{
			{Id: 1, EpTitle: "Pilot"},
			{Id: 2, EpTitle: "Next"},
		},
	}
	r := newRouterWithSvc(svc)
	req := httptest.NewRequest(http.MethodGet, "/api/v1/shows", nil)
	w := httptest.NewRecorder()
	r.ServeHTTP(w, req)
	if w.Code != http.StatusOK {
		t.Fatalf("got %d: %s", w.Code, w.Body.String())
	}
	var got []episode.Episode
	if err := json.Unmarshal(w.Body.Bytes(), &got); err != nil {
		t.Fatalf("json: %v", err)
	}
	if len(got) != 2 || got[0].EpTitle != "Pilot" {
		t.Fatalf("unexpected list: %+v", got)
	}
}

func TestListShows_Error(t *testing.T) {
	svc := &fakeSvc{listErr: errors.New("query failed")}
	r := newRouterWithSvc(svc)
	req := httptest.NewRequest(http.MethodGet, "/api/v1/shows", nil)
	w := httptest.NewRecorder()
	r.ServeHTTP(w, req)
	if w.Code != http.StatusInternalServerError {
		t.Fatalf("expected 500, got %d", w.Code)
	}
}

func TestDeleteShows_InvalidID(t *testing.T) {
	r := newRouterWithSvc(&fakeSvc{})
	req := httptest.NewRequest(http.MethodDelete, "/api/v1/shows?id=abc", nil)
	w := httptest.NewRecorder()
	r.ServeHTTP(w, req)
	if w.Code != http.StatusBadRequest {
		t.Fatalf("expected 400, got %d", w.Code)
	}
}

func TestDeleteShows_NotFound(t *testing.T) {
	svc := &fakeSvc{deleteErr: episode.ErrNotFound}
	r := newRouterWithSvc(svc)
	req := httptest.NewRequest(http.MethodDelete, "/api/v1/shows?id=99", nil)
	w := httptest.NewRecorder()
	r.ServeHTTP(w, req)
	if w.Code != http.StatusNotFound {
		t.Fatalf("expected 404, got %d", w.Code)
	}
}

func TestDeleteShows_OtherError(t *testing.T) {
	svc := &fakeSvc{deleteErr: errors.New("db down")}
	r := newRouterWithSvc(svc)
	req := httptest.NewRequest(http.MethodDelete, "/api/v1/shows?id=77", nil)
	w := httptest.NewRecorder()
	r.ServeHTTP(w, req)
	if w.Code != http.StatusInternalServerError {
		t.Fatalf("expected 500, got %d", w.Code)
	}
}

func TestDeleteShows_OK(t *testing.T) {
	svc := &fakeSvc{}
	r := newRouterWithSvc(svc)
	req := httptest.NewRequest(http.MethodDelete, "/api/v1/shows?id=11", nil)
	w := httptest.NewRecorder()
	r.ServeHTTP(w, req)
	if w.Code != http.StatusNoContent {
		t.Fatalf("expected 204, got %d", w.Code)
	}
	if svc.lastDelID != 11 {
		t.Fatalf("expected delete id 11, got %d", svc.lastDelID)
	}
}