package controller

import (
	"fmt"

	"github.com/iliadenisov/galaxy/internal/model/game"
	"github.com/iliadenisov/galaxy/internal/repo"
)

type Repo interface {
	// Lock must be called before any repository operations
	Lock() error

	// Release must be called after first and only repository operation
	Release() error

	// SaveTurn stores just generated new turn
	SaveTurn(uint, *game.Game) error

	// SaveState stores current game state updated between turns
	SaveState(*game.Game) error

	// LoadState retrieves game current state
	LoadState() (*game.Game, error)

	LoadStateSafe() (*game.Game, error)
}

type Controller struct {
	param Param
	Repo  Repo
}

type Param struct {
	StoragePath string
}

type Config func(*Param)

func NewController(config Config) (*Controller, error) {
	c := &Param{
		StoragePath: ".",
	}
	if config != nil {
		config(c)
	}
	r, err := repo.NewFileRepo(c.StoragePath)
	if err != nil {
		return nil, err
	}
	return &Controller{
		param: *c,
		Repo:  r,
	}, nil
}

func (c *Controller) ExecuteState(consumer func(Repo)) error {
	if err := c.Repo.Lock(); err != nil {
		return fmt.Errorf("execute: lock failed: %s", err)
	}
	consumer(c.Repo)
	return c.Repo.Release()
}

func (c *Controller) ExecuteGame(consumer func(Repo, *game.Game)) error {
	if err := c.Repo.Lock(); err != nil {
		return fmt.Errorf("execute: lock failed: %s", err)
	}
	g, err := c.Repo.LoadState()
	if err != nil {
		return err
	}
	consumer(c.Repo, g)
	return c.Repo.Release()
}