package serializer

import (
	"fonchain-artshow/cmd/model"
	"math"
)

func CalcPrice(total_price int64, total_ruler int32, artworksPrices []*model.ArtworkPrice) []*model.ArtworkPrice {
	price := math.Floor(float64(total_price) / float64(total_ruler))
	_, f := math.Modf(float64(total_price) / float64(total_ruler))
	if f >= 0.5 {
		price += 1
	}
	var (
		current_total_price     int64
		current_artwork_price   int64
		current_copyright_price int64

		add_total_balance     int64
		add_artwork_balance   int64
		add_copyright_balance int64

		loss_total_price     int64
		loss_artwork_price   int64
		loss_copyright_price int64
	)

	for total_price-current_total_price != 0 {
		current_total_price = calcTotalPrice(artworksPrices, add_total_balance, int64(price))
		if current_total_price != 0 {
			add_total_balance = total_price - current_total_price
		}
		if int(math.Abs(float64(add_total_balance))) < len(artworksPrices) {
			loss_total_price = add_total_balance
			break
		}
	}

	maxId, dirId := findArtworkToAdd(artworksPrices, int64(price))

	if dirId > 0 {
		artworksPrices[dirId].Price = artworksPrices[dirId].Price + loss_total_price
	} else {
		artworksPrices[maxId].Price = artworksPrices[maxId].Price + loss_total_price
	}

	for int64(float64(total_price)*0.95)-current_artwork_price != 0 {
		current_artwork_price = calcArtworkPrice(artworksPrices, add_artwork_balance)
		if current_artwork_price != 0 {
			add_artwork_balance = int64(float64(total_price)*0.95) - current_artwork_price
		}
		if int(math.Abs(float64(add_artwork_balance))) < len(artworksPrices) {
			_, f := math.Modf(float64(total_price) * 0.95)
			if f >= 0.5 {
				add_artwork_balance += 1
			}
			loss_artwork_price = add_artwork_balance
			break
		}
	}

	if dirId > 0 {
		artworksPrices[dirId].ArtworkPrice = artworksPrices[dirId].ArtworkPrice + loss_artwork_price
	} else {
		artworksPrices[maxId].ArtworkPrice = artworksPrices[maxId].ArtworkPrice + loss_artwork_price
	}

	for int64(float64(total_price)*0.05)-current_copyright_price != 0 {
		current_copyright_price = calcCopyrightPrice(artworksPrices, add_copyright_balance)
		if current_copyright_price != 0 {
			add_copyright_balance = int64(float64(total_price)*0.05) - current_copyright_price
		}
		if int(math.Abs(float64(add_copyright_balance))) < len(artworksPrices) {
			loss_copyright_price = add_copyright_balance
			break
		}
	}

	if dirId > 0 {
		artworksPrices[dirId].CopyrightPrice = artworksPrices[dirId].CopyrightPrice + loss_copyright_price
	} else {
		artworksPrices[maxId].CopyrightPrice = artworksPrices[maxId].CopyrightPrice + loss_copyright_price
	}

	return artworksPrices
}

func calcArtworkPrice(artworks []*model.ArtworkPrice, add_balance int64) int64 {
	var (
		current_artwork_price int64
		add_balance_single    float64
	)
	if math.Abs(float64(add_balance)) > 0 {
		add_balance_single = math.Floor(math.Abs(float64(add_balance)) / float64(len(artworks)))
		if add_balance < 0 {
			add_balance_single = 0 - add_balance_single
		}
	}
	for i := 0; i < len(artworks); i++ {
		artworks[i].ArtworkPrice = int64(math.Floor(float64(artworks[i].Price) * 0.95))
		artworks[i].ArtworkPrice += int64(add_balance_single)

		current_artwork_price += artworks[i].ArtworkPrice
	}
	return current_artwork_price
}

func calcCopyrightPrice(artworks []*model.ArtworkPrice, add_balance int64) int64 {
	var (
		current_copyright_price int64
		add_balance_single      float64
	)
	if math.Abs(float64(add_balance)) > 0 {
		add_balance_single = math.Floor(math.Abs(float64(add_balance)) / float64(len(artworks)))
		if add_balance < 0 {
			add_balance_single = 0 - add_balance_single
		}
	}
	for i := 0; i < len(artworks); i++ {
		artworks[i].CopyrightPrice = int64(math.Floor(float64(artworks[i].Price) * 0.05))
		artworks[i].CopyrightPrice += int64(add_balance_single)

		current_copyright_price += artworks[i].CopyrightPrice
	}
	return current_copyright_price
}

func calcTotalPrice(artworks []*model.ArtworkPrice, add_balance, price int64) int64 {
	var (
		current_total_price int64
		add_balance_single  float64
	)
	if math.Abs(float64(add_balance)) > 0 {
		add_balance_single = math.Floor(math.Abs(float64(add_balance)) / float64(len(artworks)))
		if add_balance < 0 {
			add_balance_single = 0 - add_balance_single
		}
	}
	for i := 0; i < len(artworks); i++ {
		artworks[i].Price = int64(add_balance_single)
		artworks[i].Price += int64(artworks[i].Ruler) * price

		current_total_price += artworks[i].Price
	}
	return current_total_price
}

func findArtworkToAdd(artworks []*model.ArtworkPrice, ruler_price int64) (int, int) {
	var (
		current_ruler int
		max_ruler     int
		maxIndex      int
		difIndex      int
	)

	for i := 0; i < len(artworks); i++ {
		if artworks[i].Ruler > int32(max_ruler) {
			maxIndex = i
			max_ruler = int(artworks[i].Ruler)
		}

		if artworks[i].Ruler > int32(current_ruler) {
			difIndex = i
			current_ruler = int(artworks[i].Ruler)
		} else if artworks[i].Ruler == int32(current_ruler) {
			current_ruler = 0
			difIndex = 0
		}
		//artworks[i].ShowID = show_id
		artworks[i].RulerPrice = ruler_price
	}

	return maxIndex, difIndex
}