package service

import (
	"context"
	"encoding/json"
	"testing"

	"github.com/AFASystems/presence/internal/pkg/model"
	"github.com/AFASystems/presence/internal/pkg/service"
	"github.com/segmentio/kafka-go"
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
)

func setupTestDB(t *testing.T) *gorm.DB {
	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
	if err != nil {
		t.Fatalf("Failed to open test DB: %v", err)
	}
	if err := db.AutoMigrate(&model.Gateway{}, &model.Zone{}, &model.Tracker{}, &model.TrackerZones{}, &model.Tracks{}); err != nil {
		t.Fatalf("Failed to migrate: %v", err)
	}
	return db
}

func TestSendParserConfig(t *testing.T) {
	mockWriter := &mockKafkaWriter{}
	kp := model.KafkaParser{
		ID:   "add",
		Name: "test-parser",
		Config: model.Config{
			Name:    "test-parser",
			Min:     4,
			Max:     20,
			Pattern: []string{"0x02", "0x01"},
			Configs: map[string]model.ParserConfig{},
		},
	}
	ctx := context.Background()

	err := service.SendParserConfig(kp, mockWriter, ctx)
	if err != nil {
		t.Fatalf("SendParserConfig failed: %v", err)
	}
	if len(mockWriter.messages) != 1 {
		t.Errorf("Expected 1 Kafka message, got %d", len(mockWriter.messages))
	}
	var decoded model.KafkaParser
	if err := json.Unmarshal(mockWriter.messages[0].Value, &decoded); err != nil {
		t.Fatalf("Failed to unmarshal: %v", err)
	}
	if decoded.ID != "add" || decoded.Config.Name != "test-parser" {
		t.Errorf("Expected add/test-parser, got %s/%s", decoded.ID, decoded.Config.Name)
	}
}

func TestLocationToBeaconService_EmptyID(t *testing.T) {
	db := setupTestDB(t)
	mockWriter := &mockKafkaWriter{}
	ctx := context.Background()

	msg := model.HTTPLocation{ID: "", Location: "gateway1"}
	service.LocationToBeaconService(msg, db, mockWriter, ctx)
	// Should return early, no panic
}

func TestLocationToBeaconService_WithValidData(t *testing.T) {
	db := setupTestDB(t)
	// Create prerequisite data (formatMac converts AABBCCDDEEFF -> AA:BB:CC:DD:EE:FF)
	db.Create(&model.Gateway{ID: "gw-1", MAC: "AA:BB:CC:DD:EE:FF", Floor: "1", Building: "B1", X: 10, Y: 20})
	db.Create(&model.Tracker{ID: "tr-1", MAC: "112233445566"})
	db.Create(&model.TrackerZones{ID: "tz-1", Tracker: "tr-1", ZoneList: []string{"gw-1"}})

	mockWriter := &mockKafkaWriter{}
	ctx := context.Background()

	msg := model.HTTPLocation{
		ID:       "tr-1",
		Location: "AABBCCDDEEFF",
		Distance: 2.5,
		RSSI:     -65,
	}
	service.LocationToBeaconService(msg, db, mockWriter, ctx)

	var tracker model.Tracker
	db.Where("id = ?", "tr-1").First(&tracker)
	if tracker.Location != "gw-1" {
		t.Errorf("Expected tracker location gw-1, got %s", tracker.Location)
	}
}

type mockKafkaWriter struct {
	messages []kafka.Message
}

func (m *mockKafkaWriter) WriteMessages(ctx context.Context, msgs ...kafka.Message) error {
	m.messages = append(m.messages, msgs...)
	return nil
}