package store

import (
	"encoding/json"
	"errors"
	"os"

	"github.com/samber/lo"
)

type BaseModel[T interface{}] interface {
	GetID() string
	Assign(record T)
	AssignForce(record T)
}

type BaseJsonStore[T BaseModel[T]] struct {
	data []T

	jsonFile string
}

func NewStore[T BaseModel[T]](jsonFile string) *BaseJsonStore[T] {
	r := &BaseJsonStore[T]{jsonFile: jsonFile}
	r.Init()
	return r
}

// load from json file, tmp use
func (s *BaseJsonStore[T]) Init() error {
	bytes, err := os.ReadFile(s.jsonFile)
	if err != nil {
		return errors.New("read json file error:" + err.Error())
	}

	var data []T
	if err := json.Unmarshal(bytes, &data); err != nil {
		return errors.New("parse json file error:" + err.Error())
	}

	s.data = data
	return nil
}

func (s *BaseJsonStore[T]) Refresh() error {
	return s.Init()
}

// save to json file, tmp use
func (s *BaseJsonStore[T]) Save() error {
	bytes, err := json.Marshal(s.data)
	if err != nil {
		return errors.New("marshal json file error:" + err.Error())
	}

	if err := os.WriteFile(s.jsonFile, bytes, 0777); err != nil {
		return errors.New("write json file error:" + err.Error())
	}

	return nil
}

func (s *BaseJsonStore[T]) Data() []T {
	return s.data
}

func (s *BaseJsonStore[T]) ById(id string) T {
	found, ok := lo.Find(s.data, func(p T) bool {
		return p.GetID() == id
	})
	if ok {
		return found
	}
	return found
}

// add if not exist, or force replace it
func (s *BaseJsonStore[T]) Add(record T) bool {
	return s.addOrUpdate(record, true)
}

// add if not exist, or update it, not force
func (s *BaseJsonStore[T]) Update(record T) bool {
	return s.addOrUpdate(record, false)
}

func (s *BaseJsonStore[T]) addOrUpdate(record T, replace bool) bool {
	old, ok := lo.Find(s.data, func(p T) bool {
		return p.GetID() == record.GetID()
	})
	if !ok {
		s.data = append(s.data, record)
		return true
	}

	if replace {
		old.AssignForce(record)
	} else {
		old.Assign(record)
	}

	return true
}