package rooms

import (
	"fmt"
	"sync"

	"gitea.konchin.com/ytshih/inp2025/game/server/wordle"
	"gitea.konchin.com/ytshih/inp2025/game/types"
	"github.com/google/uuid"
)

type RoomManager struct {
	mu           sync.RWMutex
	rooms        map[string]*types.Room
	gameHandlers map[string]*wordle.Handlers
}

func NewRoomManager() *RoomManager {
	return &RoomManager{
		rooms:        make(map[string]*types.Room),
		gameHandlers: make(map[string]*wordle.Handlers),
	}
}

func (rm *RoomManager) CreateRoom(creater string) (*types.Room, error) {
	room := &types.Room{
		ID:      uuid.New().String(),
		Creater: creater,
		Status:  types.RoomStatusWaiting,
		Players: []string{creater},
	}

	gameHandler := wordle.NewHandlers()

	rm.mu.Lock()
	rm.rooms[room.ID] = room
	rm.gameHandlers[room.ID] = gameHandler
	rm.mu.Unlock()

	return room, nil
}

func (rm *RoomManager) GetRooms() []*types.Room {
	rm.mu.RLock()
	defer rm.mu.RUnlock()

	rooms := make([]*types.Room, 0, len(rm.rooms))
	for _, room := range rm.rooms {
		rooms = append(rooms, room)
	}
	return rooms
}

func (rm *RoomManager) GetRoom(id string) (*types.Room, bool) {
	rm.mu.RLock()
	defer rm.mu.RUnlock()
	room, ok := rm.rooms[id]
	return room, ok
}

func (rm *RoomManager) GetGameHandler(id string) (*wordle.Handlers, bool) {
	rm.mu.RLock()
	defer rm.mu.RUnlock()
	handler, ok := rm.gameHandlers[id]
	return handler, ok
}

func (rm *RoomManager) JoinRoom(id, username string) (*types.Room, error) {
	rm.mu.Lock()
	defer rm.mu.Unlock()

	room, ok := rm.rooms[id]
	if !ok {
		return nil, fmt.Errorf("room not found")
	}

	if len(room.Players) >= 2 {
		return nil, fmt.Errorf("room is full")
	}

	for _, player := range room.Players {
		if player == username {
			return room, nil // already in room
		}
	}

	room.Players = append(room.Players, username)
	if len(room.Players) == 2 {
		room.Status = types.RoomStatusPlaying
	}

	return room, nil
}