package controller

import (
	"fmt"

	"github.com/iliadenisov/galaxy/internal/model/game"
	"github.com/iliadenisov/galaxy/internal/model/report"
	"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 with required lock acquisition
	LoadState() (*game.Game, error)

	// LoadStateSafe retrieves game current state without preliminary locking
	LoadStateSafe() (*game.Game, error)

	// SaveBattle stores a new battle protocol and battle meta data for turn t
	SaveBattle(t uint, b *report.BattleReport, m *game.BattleMeta) error

	// SaveBombing stores all prodused bombings for turn t
	SaveBombings(t uint, b []*game.Bombing) error
}

type Controller struct {
	Repo  Repo
	Cache *Cache
}

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{
		Repo: r,
	}, nil
}

func NewRepoController(r Repo) *Controller {
	return &Controller{
		Repo: r,
	}
}

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
	}
	c.Cache = NewCache(g)
	consumer(c.Repo, g)
	return c.Repo.Release()
}