package players

import (
    "fmt"
    "github.com/minus5/marketing/internal/bonus"
    "github.com/minus5/marketing/pkg/bonus/service/api"
    "sync"
)

type Repo interface {
    PlayerByGuid(playerId string) (*api.Player, error)
    PlayersByNickname(nickname string) ([]*api.Player, error)
    ActivePlayerWithNickname(nickname string) (*api.Player, error)
    PlayerUpsert(player *api.Player) error
}

var repo Repo
var indexGuid = make(map[string]*api.Player)
var lock = sync.RWMutex{}

func UseRepo(r Repo) {
    repo = r
}

func Execute(e *bonus.Event) error {
    i := e.Igrac
    if i == nil {
        return nil
    }
    // igraca imamo u cacheu
    if inCache, changedData := playerFromCache(i); inCache {
        if changedData {
            upsertPlayer(i)
        }
        return nil
    }
    // provjeri imamo li igraca u mongu
    p, err := repo.PlayerByGuid(i.Id)
    if err != nil {
        return err
    }
    // nema igraca u mongu, azuriraj indexe i insertaj dokument u mongo
    if p == nil {
        upsertPlayer(i)
        return nil
    }
    // postoji u mongu, ako su mu se promijenili podatci azuriraj indexe i dokument u mongu
    if !playerChanged(p, i) {
        return nil
    }
    upsertPlayer(i)
    return nil
}

func playerFromCache(i *bonus.Igrac) (inCache bool, changedData bool) { // dohvati igraca iz cachea i ako postoji provjeri jesu li isti podatci
    lock.RLock()
    defer lock.RUnlock()
    player, ok := indexGuid[i.Id]
    inCache = false
    changedData = false
    if !ok {
        return
    }
    inCache = true
    if !playerChanged(player, i) {
        return
    }
    changedData = true
    return
}

func upsertPlayer(i *bonus.Igrac) {
    lock.Lock()
    defer lock.Unlock()
    player := &api.Player{
        PlayerId: i.Id,
        Nickname: i.Nickname,
        Oib:      i.Oib,
        Tester:   i.Tester,
        State:    i.State,
    }
    indexGuid[i.Id] = player
    repo.PlayerUpsert(player)
}

func playerChanged(igrac *api.Player, i *bonus.Igrac) bool {
    return igrac.Nickname == i.Nickname && igrac.Tester == i.Tester && igrac.Oib == i.Oib && igrac.State == i.State
}

func GetById(playerId string) (*api.Player, error) {
    lock.Lock()
    defer lock.Unlock()
    if playerId == "" {
        return nil, fmt.Errorf("player id is empty")
    }
    if player, ok := indexGuid[playerId]; ok { // imamo li igraca u cacheu?
        return player, nil
    }
    player, err := repo.PlayerByGuid(playerId)
    if err != nil {
        return nil, err
    }
    if player == nil {
        return nil, api.ErrUnknownPlayer
    }
    indexGuid[player.PlayerId] = player
    return player, nil
}

func GetPlayersByNickname(nickname string) ([]*api.Player, error) {
    if nickname == "" {
        return nil, fmt.Errorf("nickname is empty")
    }
    players, err := repo.PlayersByNickname(nickname)
    if err != nil {
        return nil, err
    }
    return players, nil
}

func GetActivePlayerWithNickname(nickname string) (*api.Player, error) {
    if nickname == "" {
        return nil, fmt.Errorf("nickname is empty")
    }
    player, err := repo.ActivePlayerWithNickname(nickname)
    if err != nil {
        return nil, err
    }
    return player, nil
}

func IsTester(playerId string) (bool, error) {
    player, err := GetById(playerId)
    if err != nil {
        return false, err
    }
    if player == nil {
        return false, api.ErrUnknownPlayer
    }
    return player.Tester, nil
}