package mock

import (
	"context"
	"errors"
	"sync"

	"git.kundeng.us/phoenix/textsender-models/tx0/message"
	"github.com/google/uuid"
)

type MessageKey struct {
	Content string
	UserId  uuid.UUID
}

type MockMessageStore struct {
	Messages      map[uuid.UUID]*message.Message
	MessagesByKey map[MessageKey]*message.Message
	mu            sync.RWMutex
	Error         error // Optional: simulate errors
}

func NewMockMessageStore() *MockMessageStore {
	return &MockMessageStore{
		Messages:      make(map[uuid.UUID]*message.Message),
		MessagesByKey: make(map[MessageKey]*message.Message),
	}
}

func (m *MockMessageStore) CreateMessage(ctx context.Context, msg *message.Message) error {
	m.mu.Lock()
	defer m.mu.Unlock()

	if m.Error != nil {
		return m.Error
	}

	if msg.Id == uuid.Nil {
		msg.Id = uuid.New()
	}

	key := MessageKey{Content: msg.Content, UserId: msg.UserId}
	if _, exists := m.MessagesByKey[key]; exists {
		return errors.New("Message already exists")
	}

	m.Messages[msg.Id] = msg
	m.MessagesByKey[key] = msg
	return nil
}

func (m *MockMessageStore) GetAllMessages(ctx context.Context) ([]*message.Message, error) {
	m.mu.Lock()
	defer m.mu.Unlock()

	if m.Error != nil {
		return nil, m.Error
	}

	var msgs []*message.Message

	for _, msg := range m.Messages {
		msgs = append(msgs, msg)
	}

	return msgs, nil
}

func (m *MockMessageStore) GetMessageByID(ctx context.Context, id uuid.UUID) (*message.Message, error) {
	m.mu.Lock()
	defer m.mu.Unlock()

	if m.Error != nil {
		return nil, m.Error
	}

	msg := m.Messages[id]

	return msg, nil
}

func (m *MockMessageStore) MessageExists(ctx context.Context, msg *message.Message) (bool, error) {
	m.mu.Lock()
	defer m.mu.Unlock()

	if m.Error != nil {
		return false, m.Error
	}

	_, exists := m.MessagesByKey[MessageKey{Content: msg.Content, UserId: msg.UserId}]

	return exists, nil
}