package mock

import (
	"context"
	"fmt"
	"sync"

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

type ScheduledMessageKey struct {
	UserId uuid.UUID
}

type MockScheduledMessageStore struct {
	ScheduledMessages      map[uuid.UUID]*scheduling.ScheduledMessage
	ScheduledMessagesByKey map[ScheduledMessageKey]*scheduling.ScheduledMessage
	mu                     sync.RWMutex
	Error                  error // Optional: simulate errors
}

func NewMockScheduledMessageStore() *MockScheduledMessageStore {
	return &MockScheduledMessageStore{
		ScheduledMessages:      make(map[uuid.UUID]*scheduling.ScheduledMessage),
		ScheduledMessagesByKey: make(map[ScheduledMessageKey]*scheduling.ScheduledMessage),
	}
}

func (m *MockScheduledMessageStore) Get(ctx context.Context, id uuid.UUID) (*scheduling.ScheduledMessage, error) {
	m.mu.Lock()
	defer m.mu.Unlock()

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

	if id == uuid.Nil {
		return nil, fmt.Errorf("Id is nil")
	} else {
		if schMsg := m.ScheduledMessages[id]; schMsg != nil {
			return schMsg, nil
		} else {
			return nil, fmt.Errorf("Scheduled message does not exist")
		}
	}
}

func (m *MockScheduledMessageStore) FetchNextScheduledMessage(ctx context.Context) (*scheduling.ScheduledMessage, error) {
	m.mu.Lock()
	defer m.mu.Unlock()

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

	var schMsg *scheduling.ScheduledMessage
	for _, msg := range m.ScheduledMessages {
		if msg.Status == scheduling.Ready {
			msg.Status = scheduling.Processing
			schMsg = msg
			break
		}
	}

	if schMsg == nil {
		return nil, fmt.Errorf("No scheduled message is ready")
	} else {
		return schMsg, nil
	}
}

func (m *MockScheduledMessageStore) GetWithUserId(ctx context.Context, userId uuid.UUID) ([]*scheduling.ScheduledMessage, error) {
	m.mu.Lock()
	defer m.mu.Unlock()

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

	if userId == uuid.Nil {
		return nil, fmt.Errorf("User Id is nil")
	} else {
		var schMsgs []*scheduling.ScheduledMessage
		for _, schMsg := range m.ScheduledMessages {
			if schMsg.UserId == userId {
				schMsgs = append(schMsgs, schMsg)
			}
		}

		if len(schMsgs) == 0 {
			return nil, nil
		} else {
			return schMsgs, nil
		}
	}
}

func (m *MockScheduledMessageStore) CreateScheduledMessage(ctx context.Context, schedMsg *scheduling.ScheduledMessage) error {
	m.mu.Lock()
	defer m.mu.Unlock()

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

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

	key := ScheduledMessageKey{UserId: schedMsg.UserId}

	m.ScheduledMessages[schedMsg.Id] = schedMsg
	m.ScheduledMessagesByKey[key] = schedMsg
	return nil
}

func (m *MockScheduledMessageStore) UpdateStatus(ctx context.Context, id uuid.UUID, updatedStatus string) (*string, error) {
	m.mu.Lock()
	defer m.mu.Unlock()

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

	if id == uuid.Nil {
		return nil, fmt.Errorf("Id is nil")
	} else {
		if schMsg := m.ScheduledMessages[id]; schMsg != nil {
			key := ScheduledMessageKey{UserId: schMsg.UserId}

			schMsg.Status = updatedStatus
			m.ScheduledMessages[schMsg.Id] = schMsg
			m.ScheduledMessagesByKey[key] = schMsg

			return &updatedStatus, nil
		} else {
			return nil, fmt.Errorf("Scheduled message does not exist")
		}
	}
}