package data

import (
	"encoding/json"
	"fmt"
	"log"
	"os"
	"path"
	"recipe-manager/helpers"
	"recipe-manager/models"
	"recipe-manager/services/logger"
	"slices"
	"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
	redisClient       *RedisCli
}

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, redisClient *RedisCli) *Data {

	allRecipeFiles := helpers.ScanRecipeFiles(countries)

	defaultFile := "coffeethai02_600.json"

	//  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})

		// emit out latest version
		taoLogger.Log.Info("Latest version", zap.Any("country", elem.CountryID), zap.Any("version", 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)
				}

				redisClient.SetToKey(v2.Name, defaultRecipe)

				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,
		redisClient:       redisClient,
	}
}

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

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

	// concat submenu into recipe

	if countryID == "" {
		d.taoLogger.Log.Debug("GetRecipe", zap.Any("EmptyCountryId", "return default country = tha"))
		return d.CurrentRecipe["tha"]
	}

	if filename == "" {
		d.taoLogger.Log.Debug("GetRecipe", zap.Any("EmptyFilename", filename))
		return d.CurrentRecipe[countryID]
	}

	// do check if match the current pointer
	if d.CurrentFile[countryID] == filename {
		d.taoLogger.Log.Debug("GetRecipe",
			zap.Any("FileMatchCurrent", "return from stored "+filename),
			zap.Any("CurrentFile", d.CurrentFile),
			zap.Any("countryID", countryID))

		d.taoLogger.Log.Debug("CurrentRecipeOK?", zap.Any("CurrentRecipe", d.CurrentRecipe[countryID] != nil))

		// make sure recipe vesion is equal
		currentConfig := d.CurrentRecipe[countryID].MachineSetting.ConfigNumber
		// get requested version
		requestedConfig, _ := strconv.Atoi(strings.Split(strings.Split(filename, "_")[1], ".")[0])
		if currentConfig != requestedConfig {
			d.taoLogger.Log.Debug("GetRecipe", zap.Any("ActualFileNotMatch", "Skip this!"))
		} else {

			// detect patches, return original
			var cached_original_recipe models.Recipe
			err := d.redisClient.GetKeyTo(filename, &cached_original_recipe)

			if err == nil && d.redisClient.HealthCheck() == nil {
				d.taoLogger.Log.Debug("GetRecipe.NoReturnUpdated", zap.Any("target", filename))
				return &cached_original_recipe
			}

			// if equal, OK
			return d.CurrentRecipe[countryID]
		}

	}

	if recipe, ok := d.recipeMap[filename]; ok && d.redisClient.HealthCheck() != nil {
		d.taoLogger.Log.Debug("GetRecipe", zap.Any("ValidOnStored", "return from stored "+filename))
		// d.CurrentFile[countryID] = filename
		// d.CurrentCountryID[countryID] = countryID

		// make sure recipe vesion is equal
		currentConfig := d.CurrentRecipe[countryID].MachineSetting.ConfigNumber
		// get requested version
		requestedConfig, _ := strconv.Atoi(strings.Split(strings.Split(filename, "_")[1], ".")[0])
		if currentConfig != requestedConfig {
			d.taoLogger.Log.Debug("GetRecipe", zap.Any("InvalidOnStored", "Skip this!"))
		} else {

			// detect patches, return original

			var cached_original_recipe models.Recipe
			err := d.redisClient.GetKeyTo(filename, &cached_original_recipe)

			if err == nil && d.redisClient.HealthCheck() == nil {
				d.taoLogger.Log.Debug("GetRecipe.NoReturnUpdated", zap.Any("target", filename))
				return &cached_original_recipe
			}

			d.taoLogger.Log.Debug("GetRecipe.ReturnDefault", zap.Any("error_cache_recipe", err))

			// if equal, OK
			return recipe.Recipe[countryID]
		}
	}

	// change current version and read new recipe

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

	// var recipe *models.Recipe = &models.Recipe{}

	// do check if redis contains the recipe
	var cached_recipe *models.Recipe = &models.Recipe{}

	if err := d.redisClient.GetKeyTo(filename, cached_recipe); err != nil {
		d.taoLogger.Log.Debug("GetRecipe.Cached", zap.Any("GetCacheRecipeError", err))
		d.taoLogger.Log.Debug("GetRecipe", zap.String("filename", filename), zap.String("countryID", countryID))
		// d.CurrentCountryID[countryID] = countryID
		cached_recipe = nil
	}

	if cached_recipe != nil {
		d.taoLogger.Log.Debug("GetRecipe", zap.Any("Check on cached recipe invalid", cached_recipe == nil), zap.Any("test config number", cached_recipe.MachineSetting.ConfigNumber))
		// set to current
		// d.CurrentRecipe[countryID] = cached_recipe
		return cached_recipe
	}

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

	if err != nil {
		d.taoLogger.Log.Debug("GetRecipe", zap.Any("ReadRecipeError -> return default", err))
		return d.CurrentRecipe[countryID]
	}

	// cache to redis
	d.redisClient.SetToKey(filename, recipe)

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

	//. service is connected. Use from cache

	// check healthcheck redis
	var return_recipe *models.Recipe = &models.Recipe{}
	err = d.redisClient.HealthCheck()
	d.taoLogger.Log.Info("GetRecipe: HealthCheck", zap.Any("result", err))
	if d.redisClient.HealthCheck() == nil && cached_recipe != nil {
		d.taoLogger.Log.Debug("GetRecipeCached", zap.Any("cached_recipe", "yes"))
		// d.CurrentRecipe[countryID] = cached_recipe
		return_recipe = cached_recipe
	} else {
		d.taoLogger.Log.Debug("GetRecipeCached", zap.Any("cached_recipe", "no"))
		// d.CurrentRecipe[countryID] = recipe
		return_recipe = 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 return_recipe
}

// 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
				} else if len(v.SubMenu) > 0 {
					for _, subMenu := range v.SubMenu {
						if subMenu.ProductCode == productCode {
							return subMenu, 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
				} else if len(v.SubMenu) > 0 {
					for _, subMenu := range v.SubMenu {
						if subMenu.ProductCode == productCode {
							// d.taoLogger.Log.Debug("GetRecipe01ByProductCode.getSuccess", zap.Any("fromFile", filename), zap.Any("whereSource", d.recipeMap))
							return subMenu, 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 := d.GetRecipe(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, fmt.Errorf("[DEFAULT]-ERR")
	// 		} else if len(v.SubMenu) > 0 {
	// 			for _, subMenu := range v.SubMenu {
	// 				if subMenu.ProductCode == productCode {
	// 					return subMenu, fmt.Errorf("[DEFAULT]-ERR")
	// 				}
	// 			}
	// 		}
	// 	}
	// }

	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
		} else if len(v.SubMenu) > 0 {
			for _, subMenu := range v.SubMenu {
				if subMenu.ProductCode == productCode {
					// d.taoLogger.Log.Debug("GetRecipe01ByProductCode", zap.Any("productCode", productCode), zap.Any("result", subMenu))
					return subMenu, 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
			// 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 if len(v.SubMenu) > 0 {
			for _, sub := range v.SubMenu {
				if sub.ProductCode == recipe.ProductCode {
					// Log.Debug("SetValuesToRecipe.SubMenu", zap.Any("old", sub), zap.Any("new", recipe))
					// sub = recipe
					// change only changed values

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

					recipe01_Map := recipe.ToMap()

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

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

func (d *Data) SetValuesToMaterialSetting(base_mat_setting []models.MaterialSetting, updated_mat_setting models.MaterialSetting) {
	not_found := false
	global_idx := 0

	for index, v := range base_mat_setting {
		// find matched id
		if v.ID == updated_mat_setting.ID {
			// change only changed values
			for k, v := range updated_mat_setting.ToMap() {
				if !reflect.DeepEqual(base_mat_setting[index].ToMap()[k], v) {
					d.taoLogger.Log.Debug("SetValuesToMaterialSetting", zap.Any("key", k), zap.Any("old", base_mat_setting[index].ToMap()[k]), zap.Any("new", v))
					base_mat_setting[index].ToMap()[k] = v
				}
			}
		} else {
			not_found = true
			global_idx = index
		}
	}

	// is new value
	if not_found {
		base_mat_setting[global_idx+1] = updated_mat_setting
	}
}

func (d *Data) SetValuesToToppingList(base_topping_list []models.ToppingList, updated_topping_list models.ToppingList) {
	not_found := false
	global_idx := 0

	for index, v := range base_topping_list {
		// find matched id
		if v.ID == updated_topping_list.ID {
			// change only changed values
			for k, v := range updated_topping_list.ToMap() {
				if !reflect.DeepEqual(base_topping_list[index].ToMap()[k], v) {
					d.taoLogger.Log.Debug("SetValuesToToppingList", zap.Any("key", k), zap.Any("old", base_topping_list[index].ToMap()[k]), zap.Any("new", v))
					base_topping_list[index].ToMap()[k] = v
				}
			}
		} else {
			not_found = true
			global_idx = index
		}
	}

	// is new value
	if not_found {
		base_topping_list[global_idx+1] = updated_topping_list
	}
}

func (d *Data) SetValuesToToppingGroupList(base_topping_group_list []models.ToppingGroup, updated_topping_group_list models.ToppingGroup) {
	not_found := false
	global_idx := 0

	for index, v := range base_topping_group_list {

		// find matched id
		if v.GroupID == updated_topping_group_list.GroupID {
			// change only changed values
			for k, v := range updated_topping_group_list.ToMap() {
				if !reflect.DeepEqual(base_topping_group_list[index].ToMap()[k], v) {
					d.taoLogger.Log.Debug("SetValuesToToppingGroup", zap.Any("key", k), zap.Any("old", base_topping_group_list[index].ToMap()[k]), zap.Any("new", v))
					base_topping_group_list[index].ToMap()[k] = v
				}
			}
		} else {
			not_found = true
			global_idx = index
		}
	}

	// is new value
	if not_found {
		base_topping_group_list[global_idx+1] = updated_topping_group_list
	}
}

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

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

	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 := d.GetRecipe(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) GetAllToppingGroups(countryID, filename string) []models.ToppingGroup {
	if countryID == "" {
		return d.CurrentRecipe[countryID].Topping.ToppingGroup
	}

	if !strings.Contains(filename, ".tmp") {
		if filename == "" || filename == d.CurrentFile[countryID] {
			return d.CurrentRecipe[countryID].Topping.ToppingGroup
		}
		if _, ok := d.recipeMap[countryID]; ok {
			d.CurrentFile[countryID] = filename

			return d.CurrentRecipe[countryID].Topping.ToppingGroup
		}
	}

	if filename == "default" {
		filename = d.CurrentFile[countryID]
	}
	recipe := d.GetRecipe(countryID, filename)

	d.CurrentRecipe[countryID] = recipe

	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 recipe.Topping.ToppingGroup
}

func (d *Data) GetToppingsList(countryID, filename string) []models.ToppingList {
	// do return default
	if countryID == "" {
		return d.CurrentRecipe[countryID].Topping.ToppingList
	}

	// handle temporary file
	if !strings.Contains(filename, ".tmp") {
		if filename == "" || filename == d.CurrentFile[countryID] {
			return d.CurrentRecipe[countryID].Topping.ToppingList
		}
		if _, ok := d.recipeMap[countryID]; ok {
			d.CurrentFile[countryID] = filename
			return d.CurrentRecipe[countryID].Topping.ToppingList
		}
	}

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

	recipe := d.GetRecipe(countryID, filename)

	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 recipe.Topping.ToppingList
}

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 := d.GetRecipe(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 := d.GetRecipe(countryID, filename)

	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)
}

// ------ sorting ------
// FIXME: sorting not working
func (d *Data) SortRecipe(countryID, filename string, sort_by string) (error, []string) {
	// Get recipe
	recipe := d.GetRecipe(countryID, filename)

	// error code
	errorCode := 0
	emptiedComparators := make([]string, 0)

	// Sort
	switch sort_by {
	case "Product Code":
		slices.SortFunc(recipe.Recipe01, func(a, b models.Recipe01) int {

			if a.ProductCode == "" || b.ProductCode == "" {
				errorCode = 1
				emptiedComparators = append(emptiedComparators, a.ProductCode+" !compare! "+b.ProductCode)
			}

			return strings.Compare(a.ProductCode, b.ProductCode)
		})
	case "Name":
		slices.SortFunc(recipe.Recipe01, func(a, b models.Recipe01) int {

			if a.Name == "" || b.Name == "" {
				errorCode = 2
				emptiedComparators = append(emptiedComparators, a.Name+" !compare! "+b.Name)
			}

			return strings.Compare(a.Name, b.Name)
		})
	case "Other Name":
		slices.SortFunc(recipe.Recipe01, func(a, b models.Recipe01) int {

			if a.OtherName == "" || b.OtherName == "" {
				errorCode = 3
				emptiedComparators = append(emptiedComparators, a.OtherName+" !compare! "+b.OtherName)
			}

			return strings.Compare(a.OtherName, b.OtherName)
		})
	case "Description":
		slices.SortFunc(recipe.Recipe01, func(a, b models.Recipe01) int {

			if a.Description == "" || b.Description == "" {
				errorCode = 4
				emptiedComparators = append(emptiedComparators, a.Description+" !compare! "+b.Description)
			}

			return strings.Compare(a.Description, b.Description)
		})
	case "Other Description":
		slices.SortFunc(recipe.Recipe01, func(a, b models.Recipe01) int {

			if a.OtherDescription == "" || b.OtherDescription == "" {
				errorCode = 5
				emptiedComparators = append(emptiedComparators, a.OtherDescription+" !compare! "+b.OtherDescription)
			}

			return strings.Compare(a.OtherDescription, b.OtherDescription)
		})
	case "Last Updated":
		slices.SortFunc(recipe.Recipe01, func(a, b models.Recipe01) int {
			// parse date
			layout := "02-Jan-2006 15:04:05"

			if a.LastChange == "" || b.LastChange == "" {
				errorCode = 6
				emptiedComparators = append(emptiedComparators, a.ProductCode+":"+a.LastChange+" !compare! "+b.ProductCode+":"+b.LastChange)
			}

			timeA, err := time.Parse(layout, a.LastChange)
			if err != nil {
				// fmt.Println("Parse error! not in layout format: ", a.LastChange)

				errorCode = 7
				emptiedComparators = append(emptiedComparators, a.ProductCode+":"+a.LastChange)
			}

			timeB, err := time.Parse(layout, b.LastChange)
			if err != nil {
				// fmt.Println("Parse error! not in layout format: ", b.LastChange)

				errorCode = 8
				emptiedComparators = append(emptiedComparators, b.ProductCode+":"+b.LastChange)
			}

			if a.LastChange == "" && b.LastChange != "" {
				errorCode = 0
				return 1
			} else if a.LastChange != "" && b.LastChange == "" {
				errorCode = 0
				return -1
			} else if a.LastChange == "" && b.LastChange == "" {
				errorCode = 0
				return 0
			}

			return timeA.Compare(timeB)
		})
	}

	if errorCode != 0 {
		errStatus := fmt.Errorf("ERR[%v]", errorCode)
		fmt.Println(errStatus)
		return errStatus, emptiedComparators
	}

	return nil, emptiedComparators
}

// merge

func (d *Data) Merge(country string, filename string, attr string, changeKey string, updated interface{}) (string, error) {

	// change this to switch case
	if attr == "Recipe" {
		return d.MergeRecipe(country, filename, changeKey)
	} else if attr == "NoCache" {
		if updated == nil {
			return "UpdatedValueError", fmt.Errorf("updated value is nil")
		}
		return d.MergeRecipeNoCache(country, filename, updated.(models.Recipe01))
	}

	return "NotKnownAttr", nil
}

func (d *Data) MergeRecipe(country, filename, changeKey string) (string, error) {
	// get source
	prefix := "Recipe"

	// read keys
	keys, err := d.redisClient.KeyList()
	if err != nil {
		return "RedisKeysError", fmt.Errorf("error when read keys from redis: %v", err)
	}

	// fullKeyString := ""
	isLegit := false
	// // find key that contains commitId, patchSource
	for _, key := range keys {
		// Recipe_<productCode>_<commitId>_<patchSource>
		if strings.Contains(key, prefix) && key == changeKey {
			isLegit = true
		}
	}

	if !isLegit {
		return "NotLegitKey", fmt.Errorf("key not found")
	}

	// get actual value
	patchValue := models.Recipe01{}
	err = d.redisClient.GetKeyTo(changeKey, &patchValue)
	if err != nil {
		return "PatchValueError", fmt.Errorf("error while getting value from source: %v", err)
	}

	// get recipe
	// var sourceRecipe models.Recipe
	sourceRecipe := d.GetRecipe(country, filename)
	// copy(d.GetRecipe(country, filename), &sourceRecipe)

	// check address
	fmt.Println("[Source] source === recipe? ", sourceRecipe == d.GetRecipe(country, filename))

	// apply value to its source
	d.SetValuesToRecipe(sourceRecipe.Recipe01, patchValue)

	return d.finalizedVersion(country, sourceRecipe)
}

func (d *Data) MergeRecipeNoCache(country string, filename string, updatedRecipe models.Recipe01) (string, error) {
	// get recipe
	sourceRecipe := d.GetRecipe(country, filename)

	// apply value to its source
	d.SetValuesToRecipe(sourceRecipe.Recipe01, updatedRecipe)

	return d.finalizedVersion(country, sourceRecipe)
}

func (d *Data) finalizedVersion(country string, sourceRecipe *models.Recipe) (string, error) {
	// updating version
	sourceRecipe.MachineSetting.ConfigNumber += 1
	newVersionStr := strconv.Itoa(sourceRecipe.MachineSetting.ConfigNumber)

	// create new file name
	updatedFilename := ""
	prefixLocalFile := "coffeethai02_"
	if country != "tha" {
		updatedFilename = prefixLocalFile + newVersionStr + "_" + country + ".json"
	} else {
		updatedFilename = prefixLocalFile + newVersionStr + ".json"
	}

	fullUpdatedFilename := path.Join("./cofffeemachineConfig", country, updatedFilename)

	// create new file

	// handle case if file already exists, add version by 1 then search new filename in loop
	// list all files in dir
	directory := path.Join("./cofffeemachineConfig", country)
	files, err := os.ReadDir(directory)

	if err != nil {
		d.taoLogger.Log.Error("MergeRecipeNoCache: Error when read dir", zap.Error(err))
		return "ReadDirError", fmt.Errorf("error when read dir: %v", err)
	}
	for _, file := range files {
		if file.Name() == updatedFilename {
			// add version by 1
			sourceRecipe.MachineSetting.ConfigNumber += 1
			newVersionStr = strconv.Itoa(sourceRecipe.MachineSetting.ConfigNumber)

			if country != "tha" {
				updatedFilename = prefixLocalFile + newVersionStr + "_" + country + ".json"
			} else {
				updatedFilename = prefixLocalFile + newVersionStr + ".json"
			}

			fullUpdatedFilename = path.Join("./cofffeemachineConfig", country, updatedFilename)
		}
	}

	file, err := os.Create(fullUpdatedFilename)
	if err != nil {
		d.taoLogger.Log.Error("MergeRecipeNoCache: Error when create new file", zap.Error(err))
		return "CreateFileError", fmt.Errorf("error when create new file: %v", err)
	}

	// write file
	encoder := json.NewEncoder(file)
	encoder.SetIndent("", " ")
	err = encoder.Encode(sourceRecipe)

	if err != nil {
		d.taoLogger.Log.Error("MergeRecipeNoCache: Error when write file", zap.Error(err))
		return "WriteFileError", fmt.Errorf("error when write file: %v", err)
	}

	// set cache
	err = d.redisClient.SetToKey(updatedFilename, sourceRecipe)
	if err != nil {
		d.taoLogger.Log.Error("MergeRecipeNoCache: Error when set cache", zap.Error(err))
		return "SetCacheError", fmt.Errorf("error when set cache: %v", err)
	}

	return updatedFilename, nil
}