Taobin-Recipe-Manager/server/data/data.go

package data

import (
	"fmt"
	"log"
	"os"
	"path"
	"recipe-manager/helpers"
	"recipe-manager/models"
	"recipe-manager/services/logger"
	"strconv"
	"strings"
	"time"

	"reflect"

	"go.uber.org/zap"
)

type RecipeWithTimeStamps struct {
	Recipe     map[string]*models.Recipe
	TimeStamps int64
}

type Data struct {
	CurrentFile       map[string]string
	CurrentCountryID  map[string]string
	DefaultCountryMap []DefaultByCountry
	AllRecipeFiles    map[string][]helpers.RecipePath
	currentRecipe     map[string]*models.Recipe
	recipeMap         map[string]RecipeWithTimeStamps
	Countries         []helpers.CountryName
	taoLogger         *logger.TaoLogger
}

type DefaultByCountry struct {
	CountryShortName   string
	CountryLongName    string
	DefaultFileVersion int
}

var (
	countries = []helpers.CountryName{{
		CountryID:   "tha",
		CountryName: "Thailand",
	}, {
		CountryID:   "mys",
		CountryName: "Malaysia",
	}, {
		CountryID:   "aus",
		CountryName: "Australia",
	},
	}
)

func NewData(taoLogger *logger.TaoLogger) *Data {

	allRecipeFiles := helpers.ScanRecipeFiles(countries)

	defaultFile := "coffeethai02_600.json"

	// TODO: read 'version' file by country

	// versionPath := path.Join("cofffeemachineConfig", defaultCountry, "version")
	// taoLogger.Log.Debug("version", zap.Any("version path", versionPath))

	// // versionFile, err := os.Open(versionPath)
	// content, err := os.ReadFile(versionPath)

	// if err != nil {
	// 	taoLogger.Log.Debug("Error when open version file", zap.Error(err))
	// }

	// initVersion := string(content)

	// // read latest version
	// // set latest to default version
	// latest_version, err := strconv.Atoi(initVersion)

	// if err != nil {
	// 	latest_version = 600
	// }

	defaultForEachCountry := []DefaultByCountry{}

	for _, elem := range countries {
		// generate default of all countries
		currentVersionPath := path.Join("cofffeemachineConfig", elem.CountryID, "version")
		// this is default version for each country
		content, err := os.ReadFile(currentVersionPath)
		if err != nil {
			taoLogger.Log.Debug("Error when open version file", zap.Error(err))
		}

		initVersion := string(content)

		// read latest version
		latest_version, _ := strconv.Atoi(initVersion)
		defaultForEachCountry = append(defaultForEachCountry, DefaultByCountry{CountryShortName: elem.CountryID, CountryLongName: elem.CountryName, DefaultFileVersion: latest_version})
	}

	currentFileMap := make(map[string]string)
	CurrentCountryIDMap := make(map[string]string)
	currentDefaultFileForEachCountry := make(map[string]*models.Recipe)

	// all default versions as string
	versionsString := ""

	// loop default for each country

	for _, v := range defaultForEachCountry {

		for _, v2 := range allRecipeFiles[v.CountryShortName] {

			// extract filename as version
			current_version_iter, err := strconv.Atoi(strings.Split(strings.Split(v2.Name, "_")[1], ".")[0])

			if err != nil {
				continue
			}

			if current_version_iter == v.DefaultFileVersion {
				currentFileMap[v.CountryShortName] = v2.Name
				CurrentCountryIDMap[v.CountryShortName] = v.CountryLongName

				versionsString = versionsString + v.CountryShortName + ":" + strconv.Itoa(current_version_iter) + ","

				// do read default
				defaultRecipe, err := helpers.ReadRecipeFile(v.CountryShortName, v2.Name)
				if err != nil {
					log.Panic("Error when read default recipe file for each country:", v.CountryShortName, err)
				}

				currentDefaultFileForEachCountry[v.CountryShortName] = defaultRecipe
				break
			}
		}
	}

	// for _, v := range allRecipeFiles[defaultCountry] {

	// 	// extract filename as version
	// 	current_version_iter, err := strconv.Atoi(strings.Split(strings.Split(v.Name, "_")[1], ".")[0])

	// 	if err != nil {
	// 		continue
	// 	}

	// 	if current_version_iter == latest_version {
	// 		// taoLogger.Log.Debug("current_version_iter", zap.Any("current_version_iter", current_version_iter))
	// 		// set latest
	// 		latest_version = current_version_iter
	// 		defaultFile = v.Name
	// 		break
	// 	}
	// }

	// FIXME: default file bug. do assign each default recipe model to each country

	// taoLogger.Log.Debug("defaultFile", zap.Any("defaultFile", defaultFile), zap.Any("latest_version", versionsString))

	// defaultRecipe, err := helpers.ReadRecipeFile(defaultCountry, defaultFile)

	// if err != nil {
	// 	log.Panic("Error when read default recipe file:", err)
	// }

	return &Data{
		CurrentFile:      currentFileMap,
		CurrentCountryID: CurrentCountryIDMap,
		AllRecipeFiles:   allRecipeFiles,
		currentRecipe:    currentDefaultFileForEachCountry,
		recipeMap: map[string]RecipeWithTimeStamps{
			defaultFile: {
				Recipe:     currentDefaultFileForEachCountry,
				TimeStamps: time.Now().Unix(),
			},
		},
		Countries:         countries,
		taoLogger:         taoLogger,
		DefaultCountryMap: defaultForEachCountry,
	}
}

func (d *Data) GetRecipe(countryID, filename string) *models.Recipe {

	d.taoLogger.Log.Debug("invoke GetRecipe", zap.String("countryID", countryID), zap.String("filename", filename))

	if countryID == "" {
		return d.currentRecipe["tha"]
	}

	if filename == "" || filename == d.CurrentFile[countryID] {
		return d.currentRecipe[countryID]
	}

	if recipe, ok := d.recipeMap[filename]; ok {
		d.CurrentFile[countryID] = filename
		// d.CurrentCountryID[countryID] = countryID
		return recipe.Recipe[countryID]
	}

	// change current version and read new recipe

	if filename == "default" {
		filename = d.CurrentFile[countryID]
	}

	// d.CurrentFile[countryID] = filename
	d.taoLogger.Log.Debug("GetRecipe", zap.String("filename", filename), zap.String("countryID", countryID))
	// d.CurrentCountryID[countryID] = countryID
	recipe, err := helpers.ReadRecipeFile(countryID, filename)

	if err != nil {
		d.taoLogger.Log.Error("GetRecipe: Error when read recipe file, Return default recipe", zap.Error(err))
		return d.currentRecipe[countryID]
	}

	d.currentRecipe[countryID] = recipe

	// save to map
	if len(d.recipeMap) > 5 { // limit keep in memory 5 version
		// remove oldest version
		var oldestVersion string
		var oldestTime int64
		for k, v := range d.recipeMap {
			if oldestTime == 0 || v.TimeStamps < oldestTime {
				oldestTime = v.TimeStamps
				oldestVersion = k
			}
		}
		delete(d.recipeMap, oldestVersion)
	}

	d.recipeMap[filename] = RecipeWithTimeStamps{
		Recipe:     d.currentRecipe,
		TimeStamps: time.Now().Unix(),
	}

	return d.currentRecipe[countryID]
}

// func (d *Data) GetRecipe01() []models.Recipe01 {
// 	return d.currentRecipe.Recipe01
// }

// func (d *Data) GetCurrentRecipe() *models.Recipe {
// 	return d.currentRecipe
// }

func (d *Data) GetRecipe01ByProductCode(filename, countryID, productCode string) (models.Recipe01, error) {

	// try convert
	if len(countryID) != 3 {
		for k, v := range d.CurrentCountryID {
			fmt.Println("GetRecipe01ByProductCode.Iterate", k, v, v == countryID)
			if v == countryID {
				countryID = k
				break
			}
		}
	}
	fmt.Println("GetRecipe01ByProductCode", filename, countryID, productCode)

	if !strings.Contains(filename, "tmp") {
		if filename == "" || filename == d.CurrentFile[countryID] {
			// , d.CurrentFile, countryID, "result by country id", len(d.currentRecipe[countryID].Recipe01)
			fmt.Println("GetRecipe01ByProductCode.ReadCurrent::filename", filename)
			fmt.Println("GetRecipe01ByProductCode.ReadCurrent::countryID", countryID)
			fmt.Println("GetRecipe01ByProductCode.ReadCurrent::CurrentFile", d.CurrentFile)
			fmt.Println("GetRecipe01ByProductCode.ReadCurrent::CurrentCountryID", d.CurrentCountryID)

			for _, v := range d.currentRecipe[countryID].Recipe01 {
				if v.ProductCode == productCode {
					return v, nil
				}
			}
			fmt.Println("No result in current recipe", countryID)
		} else if recipe, ok := d.recipeMap[filename]; ok {
			fmt.Println("GetRecipe01ByProductCode.ReadMap", filename, d.CurrentFile, recipe.Recipe[countryID], "countryID=", countryID)
			for _, v := range recipe.Recipe[countryID].Recipe01 {
				if v.ProductCode == productCode {
					d.taoLogger.Log.Debug("GetRecipe01ByProductCode.getSuccess", zap.Any("fromFile", filename), zap.Any("whereSource", d.recipeMap))
					return v, nil
				}
			}
			d.taoLogger.Log.Debug("GetRecipe01ByProductCode.getFail", zap.Any("fromFile", filename), zap.Any("whereSource", d.recipeMap))
		}
	}

	d.taoLogger.Log.Debug("GetRecipe01ByProductCode", zap.Any("filename", filename), zap.Any("countryID", countryID), zap.Any("productCode", productCode))

	if filename == "default" {
		filename = d.CurrentFile[countryID]
	}

	// d.CurrentFile[countryID] = filename
	// d.CurrentCountryID[countryID] = countryID

	for _, v := range countries {
		if v.CountryName == countryID {
			// d.CurrentCountryID[countryID] = v.CountryID
			countryID = v.CountryID
			break
		}
	}

	recipe, err := helpers.ReadRecipeFile(countryID, filename)

	if err != nil {
		d.taoLogger.Log.Error("GetRecipe01ByProductCode: Error when read recipe file, Return default recipe", zap.Error(err))
		for _, v := range d.currentRecipe[countryID].Recipe01 {
			if v.ProductCode == productCode {
				return v, nil
			}
		}
	}

	d.taoLogger.Log.Debug("GetRecipe01ByProductCode", zap.Any("productCode", productCode), zap.Any("version", recipe.MachineSetting.ConfigNumber))

	d.currentRecipe[countryID] = recipe

	// save to map
	if len(d.recipeMap) > 5 { // limit keep in memory 5 version
		// remove oldest version
		var oldestVersion string
		var oldestTime int64
		for k, v := range d.recipeMap {
			if oldestTime == 0 || v.TimeStamps < oldestTime {
				oldestTime = v.TimeStamps
				oldestVersion = k
			}
		}
		delete(d.recipeMap, oldestVersion)
	}

	d.recipeMap[filename] = RecipeWithTimeStamps{
		Recipe:     d.currentRecipe,
		TimeStamps: time.Now().Unix(),
	}

	for _, v := range d.currentRecipe[countryID].Recipe01 {
		if v.ProductCode == productCode {
			// d.taoLogger.Log.Debug("GetRecipe01ByProductCode", zap.Any("productCode", productCode), zap.Any("result", v))
			return v, nil
		}
	}

	return models.Recipe01{}, fmt.Errorf("product code: %s not found", productCode)
}

func (d *Data) SetValuesToRecipe(base_recipe []models.Recipe01, recipe models.Recipe01) {
	not_found := false
	global_idx := 0
	for index, v := range base_recipe {
		if v.ProductCode == recipe.ProductCode {
			// Log.Debug("SetValuesToRecipe", zap.Any("old", v), zap.Any("new", recipe))
			// v = recipe
			// TODO: change only changed values

			// transform to map
			base_recipe01_Map := v.ToMap()

			recipe01_Map := recipe.ToMap()

			for k, v := range recipe01_Map {
				if !reflect.DeepEqual(base_recipe01_Map[k], v) {
					d.taoLogger.Log.Debug("SetValuesToRecipe", zap.Any("key", k), zap.Any("old", base_recipe01_Map[k]), zap.Any("new", v))
					base_recipe01_Map[k] = v
				}
			}

			base_recipe[index] = base_recipe[index].FromMap(base_recipe01_Map)

			not_found = false
			break
		} else {
			not_found = true
			global_idx = index
		}
	}

	if not_found {
		base_recipe[global_idx+1] = recipe
	}
}

func (d *Data) GetMaterialSetting(countryID, filename string) []models.MaterialSetting {
	result := make([]models.MaterialSetting, 0)

	if countryID == "" {
		copy(result, d.currentRecipe[countryID].MaterialSetting)
		return result
	}

	if !strings.Contains(filename, "tmp") {
		if filename == "" || filename == d.CurrentFile[countryID] {
			// copy(result, d.currentRecipe[countryID].MaterialSetting)
			// d.taoLogger.Log.Debug("GetMaterialSetting", zap.Any("result", result))
			return d.currentRecipe[countryID].MaterialSetting
		}

		if recipe, ok := d.recipeMap[filename]; ok {
			copy(result, recipe.Recipe[countryID].MaterialSetting)
			d.CurrentFile[countryID] = filename
			// d.CurrentCountryID[countryID] = countryID
			return d.currentRecipe[countryID].MaterialSetting
		}
	}

	if filename == "default" {
		filename = d.CurrentFile[countryID]
	}

	// d.taoLogger.Log.Debug("GetMaterialSetting", zap.Any("filename", filename), zap.Any("countryID", countryID))

	// d.CurrentFile[countryID] = filename
	// d.CurrentCountryID[countryID] = countryID
	recipe, err := helpers.ReadRecipeFile(countryID, filename)

	if err != nil {
		d.taoLogger.Log.Error("GetMaterialSetting: Error when read recipe file, Return default recipe", zap.Error(err))
		copy(result, d.currentRecipe[countryID].MaterialSetting)
		return d.currentRecipe[countryID].MaterialSetting
	}

	// d.taoLogger.Log.Debug("GetMaterialSetting", zap.Any("recipe", recipe.MaterialSetting))

	d.currentRecipe[countryID] = recipe

	// save to map
	if len(d.recipeMap) > 5 { // limit keep in memory 5 version
		// remove oldest version
		var oldestVersion string
		var oldestTime int64
		for k, v := range d.recipeMap {
			if oldestTime == 0 || v.TimeStamps < oldestTime {
				oldestTime = v.TimeStamps
				oldestVersion = k
			}
		}
		delete(d.recipeMap, oldestVersion)
	}

	d.recipeMap[filename] = RecipeWithTimeStamps{
		Recipe:     d.currentRecipe,
		TimeStamps: time.Now().Unix(),
	}

	// copy(result, recipe.MaterialSetting)
	return recipe.MaterialSetting
}

func (d *Data) GetMaterialCode(ids []uint64, countryID, filename string) []models.MaterialCode {
	var result []models.MaterialCode

	if filename == "" || filename == d.CurrentFile[countryID] {
		result = d.currentRecipe[countryID].MaterialCode
	} else if recipe, ok := d.recipeMap[filename]; ok {
		d.CurrentFile[countryID] = filename
		return recipe.Recipe[countryID].MaterialCode
	} else {

		if filename == "default" {
			filename = d.CurrentFile[countryID]
		}

		// d.CurrentFile[countryID] = filename
		// d.CurrentCountryID[countryID] = countryID
		recipe, err := helpers.ReadRecipeFile(countryID, filename)

		if err != nil {
			d.taoLogger.Log.Error("GetMaterialCode: Error when read recipe file, Return default recipe", zap.Error(err))
			return d.currentRecipe[countryID].MaterialCode
		}

		d.currentRecipe[countryID] = recipe

		// save to map
		if len(d.recipeMap) > 5 { // limit keep in memory 5 version
			// remove oldest version
			var oldestVersion string
			var oldestTime int64
			for k, v := range d.recipeMap {
				if oldestTime == 0 || v.TimeStamps < oldestTime {
					oldestTime = v.TimeStamps
					oldestVersion = k
				}
			}
			delete(d.recipeMap, oldestVersion)
		}

		d.recipeMap[filename] = RecipeWithTimeStamps{
			Recipe:     d.currentRecipe,
			TimeStamps: time.Now().Unix(),
		}

		result = d.currentRecipe[countryID].MaterialCode
	}

	if len(ids) == 0 {
		return result
	}

	resultFilter := make([]models.MaterialCode, len(ids))
	for _, id := range ids {
		if id == 0 {
			continue
		}

		for _, m := range result {
			if m.MaterialID == id {
				resultFilter = append(resultFilter, m)
				break
			}
		}
	}

	return resultFilter
}

func (d *Data) GetToppings(countryID, filename string) models.Topping {

	if filename == "" || filename == d.CurrentFile[countryID] {
		return d.currentRecipe[countryID].Topping
	} else if recipe, ok := d.recipeMap[filename]; ok {
		d.CurrentFile[countryID] = filename
		return recipe.Recipe[countryID].Topping
	}

	if filename == "default" {
		filename = d.CurrentFile[countryID]
	}

	// d.CurrentFile[countryID] = filename
	// d.CurrentCountryID[countryID] = countryID
	recipe, err := helpers.ReadRecipeFile(countryID, filename)

	if err != nil {
		d.taoLogger.Log.Error("GetToppings: Error when read recipe file, Return default recipe", zap.Error(err))
		return d.currentRecipe[countryID].Topping
	}

	d.currentRecipe[countryID] = recipe

	return recipe.Topping
}

func (d *Data) GetToppingsOfRecipe(countryID, filename string, productCode string) ([]models.ToppingSet, error) {

	if filename == "default" {
		filename = d.CurrentFile[countryID]
	}

	recipe, err := d.GetRecipe01ByProductCode(filename, countryID, productCode)

	if err != nil {
		d.taoLogger.Log.Error("GetToppingOfRecipe: Error when read recipe file, Return default recipe", zap.Error(err))
		return []models.ToppingSet{}, err
	}

	return recipe.ToppingSet, nil
}

func (d *Data) GetSubmenusOfRecipe(countryID, filename, productCode string) ([]models.Recipe01, error) {

	if filename == "default" {
		filename = d.CurrentFile[countryID]
	}

	recipe, err := d.GetRecipe01ByProductCode(filename, countryID, productCode)

	if err != nil {
		d.taoLogger.Log.Error("GetSubmenusOfRecipe: Error when read recipe file, Return default recipe", zap.Error(err))
		return []models.Recipe01{}, err
	}

	submenu := recipe.SubMenu

	if submenu == nil {
		return []models.Recipe01{}, fmt.Errorf("no submenu")
	}

	return submenu, nil

}

func (d *Data) GetCountryNameByID(countryID string) (string, error) {
	for _, country := range d.Countries {
		if country.CountryID == countryID {
			return country.CountryName, nil
		}
	}
	return "", fmt.Errorf("country ID: %s not found", countryID)
}

func (d *Data) GetCountryIDByName(countryName string) (string, error) {
	for _, country := range d.Countries {
		if country.CountryName == countryName {
			return country.CountryID, nil
		}
	}
	return "", fmt.Errorf("country name: %s not found", countryName)
}