package service

import (
	"database/sql"
	"testing"
	"time"

	"github.com/daniil/homelab-api/internal/model"
)

func TestNewTaskService(t *testing.T) {
	svc := NewTaskService(nil)
	if svc == nil {
		t.Fatal("expected non-nil TaskService")
	}
}

// createNextRecurrence returns without DB call for unknown recurrence types.
func TestCreateNextRecurrence_UnknownType(t *testing.T) {
	svc := &TaskService{}
	task := &model.Task{
		UserID:             1,
		Title:              "Test Task",
		IsRecurring:        true,
		RecurrenceType:     sql.NullString{String: "unknown_type", Valid: true},
		RecurrenceInterval: 1,
		DueDate:            sql.NullTime{Time: time.Now().AddDate(0, 0, 1), Valid: true},
	}
	svc.createNextRecurrence(task)
}

// createNextRecurrence stops when next date is past end date (no DB call needed).
// Each case ensures nextDueDate > endDate so we exit before repo.Create.
func TestCreateNextRecurrence_PastEndDate(t *testing.T) {
	svc := &TaskService{}
	yesterday := time.Now().AddDate(0, 0, -1)

	tests := []struct {
		name           string
		recurrenceType string
		currentDue     time.Time
		endDate        time.Time
	}{
		{
			// daily: currentDue=2 days ago, nextDue=yesterday; endDate=3 days ago => next > end
			name:           "daily past end",
			recurrenceType: "daily",
			currentDue:     time.Now().AddDate(0, 0, -2),
			endDate:        time.Now().AddDate(0, 0, -3),
		},
		{
			// weekly: currentDue=7 days ago, nextDue=today; endDate=yesterday => next > end
			name:           "weekly past end",
			recurrenceType: "weekly",
			currentDue:     time.Now().AddDate(0, 0, -7),
			endDate:        yesterday,
		},
		{
			// monthly: currentDue=1 month ago, nextDue=today; endDate=yesterday => next > end
			name:           "monthly past end",
			recurrenceType: "monthly",
			currentDue:     time.Now().AddDate(0, -1, 0),
			endDate:        yesterday,
		},
		{
			// custom: currentDue=2 days ago, nextDue=yesterday; endDate=3 days ago => next > end
			name:           "custom past end",
			recurrenceType: "custom",
			currentDue:     time.Now().AddDate(0, 0, -2),
			endDate:        time.Now().AddDate(0, 0, -3),
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			task := &model.Task{
				UserID:             1,
				Title:              "Recurring Task",
				IsRecurring:        true,
				RecurrenceType:     sql.NullString{String: tt.recurrenceType, Valid: true},
				RecurrenceInterval: 1,
				DueDate:            sql.NullTime{Time: tt.currentDue, Valid: true},
				RecurrenceEndDate:  sql.NullTime{Time: tt.endDate, Valid: true},
			}
			svc.createNextRecurrence(task)
		})
	}
}

// interval=0 gets normalized to 1 inside createNextRecurrence
func TestCreateNextRecurrence_IntervalNormalization(t *testing.T) {
	svc := &TaskService{}
	task := &model.Task{
		UserID:             1,
		Title:              "Test",
		IsRecurring:        true,
		RecurrenceType:     sql.NullString{String: "unknown_type", Valid: true},
		RecurrenceInterval: 0,
		DueDate:            sql.NullTime{Time: time.Now().AddDate(0, 0, -10), Valid: true},
	}
	// unknown type returns before DB call, and interval normalization still runs
	svc.createNextRecurrence(task)
}