package test

import (
	gm "db_service/gorm_models"
	"db_service/models"
	helper "db_service/pkg"
	"encoding/json"
	"fmt"
	"log"
	"os"
	"strconv"
	"sync"

	"gorm.io/driver/mysql"
	"gorm.io/gorm"
)

var mainCategories []gm.Category
var baza *gorm.DB
var mainImportWG, famAndSellerWG sync.WaitGroup
var families []gm.AttributeFamily
var sellers []gm.MarketplaceSeller
var attributesMap = make(map[string]gm.Attribute)

func StartTest() error {
	baza, err := gorm.Open(mysql.Open(os.Getenv("database_url")), &gorm.Config{})

	if err != nil {
		return err
	}

	//get categories from mysql on main thread
	mainCategories = gm.GetMainCategories(baza)

	famAndSellerWG.Add(3)
	//get attribute families from mysql with gorutine
	go func() {
		defer famAndSellerWG.Done()
		families = gm.GetFamilies(baza)
	}()

	//get sellers families from mysql with gorutine
	go func() {
		defer famAndSellerWG.Done()
		sellers = gm.GetSellers(baza)
	}()

	go func() {
		defer famAndSellerWG.Done()
		var attributes = gm.GetAttributes(baza)
		for _, atrattribute := range attributes {
			attributesMap[atrattribute.Code] = atrattribute
		}
	}()

	mainImportWG.Add(len(mainCategories))

	for _, element := range mainCategories {
		slug := element.Translations[0].Slug

		go startImport("ty_db_"+slug, baza)

		// fmt.Println(<-result)
	}

	mainImportWG.Wait()
	fmt.Println("Terminating Program")

	return nil
}

func startImport(dbName string, db *gorm.DB) {
	defer mainImportWG.Done()

	dbExists := helper.CheckDBExists(os.Getenv("couch_db_source") + dbName)
	fmt.Println(dbName)

	if dbExists {

		totalDocCount := getTotalDocumentCount(dbName)
		skip := 0
		limit := 100

		for skip < totalDocCount {

			var response models.BagistoModelResponse

			url := fmt.Sprintf("%s%s/_all_docs?include_docs=true&limit=%v&skip=%v", os.Getenv("couch_db_source"), dbName, limit, skip)

			fmt.Println(url)

			skip += limit

			body, err := helper.SendRequest("GET", url, nil, "", true)

			if err != nil {
				fmt.Println(err.Error())
				continue
			}

			err = json.Unmarshal(body, &response)

			if err != nil {
				log.Println(err.Error())
				continue
			}

			//itearate 100 row products
			for _, element := range response.Rows {
				importProduct(element.Doc, db)
			}
		}
	} else {
		fmt.Println(dbName + "+doesnt exist")
	}

}

func getTotalDocumentCount(db string) int {

	var response models.DBDocCountResponse

	url := os.Getenv("couch_db_source") + db

	body, err := helper.SendRequest("GET", url, nil, "", true)

	if err != nil {
		log.Println(err.Error())
		return 0
	}

	err = json.Unmarshal(body, &response)
	if err != nil {
		log.Println(err.Error())
		return 0
	}

	return response.DocCount
}

func importProduct(product models.Product, db *gorm.DB) {

	famAndSellerWG.Wait() //wait until attribute families and sellers are not get from mysql

	var categories []gm.Category
	var brand gm.Brand

	errCat := db.Find(&categories, product.Categories).Error

	if errCat != nil {
		log.Println(errCat)
		return
	}

	if product.Brand != "" {
		brand = gm.FindOrCreateBrand(db, product.Brand, categories)
	}

	iproduct := gm.Product{
		Sku:               product.ProductGroupID,
		Type:              "simple",
		AttributeFamilyID: families[0].ID,
		Brand:             brand,
	}

	for _, element := range product.Images {
		iproduct.Images = append(iproduct.Images, gm.ProductImage{Type: "cdn", Path: element})
	}

	if product.ColorVariantCount > 0 || len(product.SizeVariants) > 0 {
		iproduct.Type = "configurable"
		iproduct.AttributeFamilyID = families[1].ID
	}

	err := db.Select("Sku", "Type", "AttributeFamilyID", "CreatedAt", "UpdatedAt").Create(&iproduct).Error

	if err != nil {
		log.Println(err)
		return
	}

	// mainProductFlat := gm.ProductFlat{}
	mainProductAttributeValues := assignAttributes(iproduct.ID, &product)

	if iproduct.Type == "simple" {
		mainProductAttributeValues = append(mainProductAttributeValues, getPriceAttributes(iproduct.ID, &product.Price)...)
	} else if len(product.ColorVariants) > 0 || len(product.SizeVariants) > 0 {

		var productVariants []gm.Product

		if len(product.ColorVariants) > 0 {
			//attach super attributes color
			superAttribute := gm.ProductSuperAttribute{ProductID: iproduct.ID, AttributeID: attributesMap["color"].ID}
			db.Create(&superAttribute)
			var description string
			for _, colorVariant := range product.ColorVariants {
				weight, _ := strconv.ParseFloat(colorVariant.Weight, 64)

				for _, desc := range colorVariant.Descriptions {
					description += "<p>" + desc.Description + "</p>"
				}

				colorOption := gm.GetAttributeOption(db, attributesMap["color"].ID, colorVariant.Color)

				if len(colorVariant.SizeVariants) > 0 {

					for _, sizeVariant := range colorVariant.SizeVariants {

						if sizeVariant.Sellable {
							sku := fmt.Sprintf("%s-%s-%d-col-size", colorVariant.ProductGroupID, colorVariant.ProductNumber, sizeVariant.ItemNumber)
							sizeOption := gm.GetAttributeOption(db, attributesMap["size"].ID, sizeVariant.AttributeValue)
							attributes := []gm.ProductAttributeValue{
								{AttributeID: attributesMap["sku"].ID, TextValue: sku, Channel: "default", Locale: "tm"},
								{AttributeID: attributesMap["product_number"].ID, TextValue: fmt.Sprintf("%s-%d", colorVariant.ProductNumber, sizeVariant.ItemNumber), Channel: "default", Locale: "tm"},
								{AttributeID: attributesMap["name"].ID, TextValue: colorVariant.Name, Channel: "default", Locale: "tm"},
								{AttributeID: attributesMap["weight"].ID, FloatValue: weight, Channel: "default", Locale: "tm"},
								// {AttributeID: attributesMap["source"].ID, TextValue: colorVariant.URLKey, Channel: "default", Locale: "tm"},
								{AttributeID: attributesMap["status"].ID, BooleanValue: true, Channel: "default", Locale: "tm"},
								{AttributeID: attributesMap["visible_individually"].ID, BooleanValue: true, Channel: "default", Locale: "tm"},
								{AttributeID: attributesMap["url_key"].ID, TextValue: sku, Channel: "default", Locale: "tm"},
								// {AttributeID: attributesMap["favoritesCount"].ID, IntegerValue: colorVariant.FavoriteCount, Channel: "default", Locale: "tm"},
								{AttributeID: attributesMap["description"].ID, TextValue: description, Channel: "default", Locale: "tm"},
								{
									AttributeID:  attributesMap["color"].ID,
									IntegerValue: int(colorOption.ID),
									Channel:      "default",
									Locale:       "tm",
								}, {
									AttributeID:  attributesMap["size"].ID,
									IntegerValue: int(sizeOption.ID),
									Channel:      "default",
									Locale:       "tm",
								},
							}

							if sizeVariant.Price.OriginalPrice.Value > sizeVariant.Price.DiscountedPrice.Value {
								attributes = append(attributes, []gm.ProductAttributeValue{
									{AttributeID: attributesMap["price"].ID, FloatValue: sizeVariant.Price.OriginalPrice.Value, Channel: "default", Locale: "tm"},
									{AttributeID: attributesMap["special_price"].ID, FloatValue: sizeVariant.Price.DiscountedPrice.Value, Channel: "default", Locale: "tm"},
								}...)

							} else {
								attributes = append(attributes, gm.ProductAttributeValue{AttributeID: attributesMap["price"].ID, FloatValue: sizeVariant.Price.OriginalPrice.Value, Channel: "default", Locale: "tm"})
							}

							productVariant := gm.Product{
								ParentID:          iproduct.ID,
								Type:              "simple",
								AttributeFamily:   iproduct.AttributeFamily,
								Sku:               sku,
								Brand:             iproduct.Brand,
								AttributeValues:   attributes,
								AttributeFamilyID: iproduct.AttributeFamilyID,
							}

							for _, element := range colorVariant.Images {
								productVariant.Images = append(iproduct.Images, gm.ProductImage{Type: "cdn", Path: element})
							}
							//todo assign images
							productVariants = append(productVariants, productVariant)
						}

					}
				} else if colorVariant.IsSellable {

					colorOption := gm.GetAttributeOption(db, attributesMap["color"].ID, colorVariant.Color)
					attributes := collectAttributes(&colorVariant, &colorOption)

					if colorVariant.Price.OriginalPrice.Value > colorVariant.Price.DiscountedPrice.Value {
						attributes = append(attributes, []gm.ProductAttributeValue{
							{AttributeID: attributesMap["price"].ID, FloatValue: colorVariant.Price.OriginalPrice.Value, Channel: "default", Locale: "tm"},
							{AttributeID: attributesMap["special_price"].ID, FloatValue: colorVariant.Price.DiscountedPrice.Value, Channel: "default", Locale: "tm"},
						}...)

					} else {
						attributes = append(attributes, gm.ProductAttributeValue{AttributeID: attributesMap["price"].ID, FloatValue: colorVariant.Price.OriginalPrice.Value, Channel: "default", Locale: "tm"})
					}

					sku := fmt.Sprintf("%s-%s-col", iproduct.Sku, colorVariant.ProductNumber)

					productVariant := gm.Product{
						ParentID:          iproduct.ID,
						Type:              "simple",
						AttributeFamily:   iproduct.AttributeFamily,
						Sku:               sku,
						Brand:             iproduct.Brand,
						AttributeValues:   attributes,
						AttributeFamilyID: iproduct.AttributeFamilyID,
					}

					for _, element := range colorVariant.Images {
						productVariant.Images = append(iproduct.Images, gm.ProductImage{Type: "cdn", Path: element})
					}

					productVariants = append(productVariants, productVariant)
				}
			}
		}

		if len(product.SizeVariants) > 0 {
			//attach super attributes size
			superAttribute := gm.ProductSuperAttribute{ProductID: iproduct.ID, AttributeID: attributesMap["size"].ID}
			db.Create(&superAttribute)

			var description string
			for _, desc := range product.Descriptions {
				description += "<p>" + desc.Description + "</p>"
			}
			weight, _ := strconv.ParseFloat(product.Weight, 64)

			for _, sizeVariant := range product.SizeVariants {

				if sizeVariant.Sellable {
					sku := fmt.Sprintf("%s-%s-%d-size", iproduct.Sku, product.ProductNumber, sizeVariant.ItemNumber)
					sizeOption := gm.GetAttributeOption(db, attributesMap["size"].ID, sizeVariant.AttributeValue)

					attributes := []gm.ProductAttributeValue{
						{AttributeID: attributesMap["sku"].ID, TextValue: sku, Channel: "default", Locale: "tm"},
						{AttributeID: attributesMap["product_number"].ID, TextValue: string(sizeVariant.ItemNumber), Channel: "default", Locale: "tm"},
						{AttributeID: attributesMap["name"].ID, TextValue: product.Name, Channel: "default", Locale: "tm"},
						{AttributeID: attributesMap["weight"].ID, FloatValue: weight, Channel: "default", Locale: "tm"},
						// {AttributeID: attributesMap["source"].ID, TextValue: product.URLKey, Channel: "default", Locale: "tm"},
						{AttributeID: attributesMap["status"].ID, BooleanValue: true, Channel: "default", Locale: "tm"},
						{AttributeID: attributesMap["visible_individually"].ID, BooleanValue: true, Channel: "default", Locale: "tm"},
						{AttributeID: attributesMap["url_key"].ID, TextValue: sku, Channel: "default", Locale: "tm"},
						// {AttributeID: attributesMap["favoritesCount"].ID, IntegerValue: product.FavoriteCount, Channel: "default", Locale: "tm"},
						{AttributeID: attributesMap["description"].ID, TextValue: description, Channel: "default", Locale: "tm"},
						{
							AttributeID:  attributesMap["size"].ID,
							IntegerValue: int(sizeOption.ID),
							Channel:      "default",
							Locale:       "tm",
						},
					}

					if sizeVariant.Price.OriginalPrice.Value > sizeVariant.Price.DiscountedPrice.Value {
						attributes = append(attributes, []gm.ProductAttributeValue{
							{AttributeID: attributesMap["price"].ID, FloatValue: sizeVariant.Price.OriginalPrice.Value, Channel: "default", Locale: "tm"},
							{AttributeID: attributesMap["special_price"].ID, FloatValue: sizeVariant.Price.DiscountedPrice.Value, Channel: "default", Locale: "tm"},
						}...)

					} else {
						attributes = append(attributes, gm.ProductAttributeValue{AttributeID: attributesMap["price"].ID, FloatValue: sizeVariant.Price.OriginalPrice.Value, Channel: "default", Locale: "tm"})
					}

					productVariant := gm.Product{
						ParentID:          iproduct.ID,
						Type:              "simple",
						AttributeFamily:   iproduct.AttributeFamily,
						Sku:               sku,
						Brand:             iproduct.Brand,
						AttributeValues:   attributes,
						AttributeFamilyID: iproduct.AttributeFamilyID,
					}

					// for _, element := range colorVariant.Images {
					// 	productVariant.Images = append(iproduct.Images, gm.ProductImage{Type: "cdn", Path: element})
					// }

					productVariants = append(productVariants, productVariant)

				}
			}
		}

		db.Create(&productVariants) //todo assign all with categories
	}

	db.Model(&iproduct).Association("Categories").Append(categories)
	var err2 = db.Create(&mainProductAttributeValues).Error

	if err2 != nil {
		log.Println(err)
	}
	// panic("'hassiktir'")
	//todo gorm transactions
	//todo Attributes source, cinsiyet

	// if len(product.Attributes) > 0 {
	// 	iproduct.AttrbuteFamily = getAttributeFamily()
	// }

	//todo seller product, meta keys
	// if($data['vendor'] && $seller = $this->vendorRepository->findOneByField('url',$data['vendor'])){
	// 	$this->createSellerProduct($parentProduct, $seller->id);
	// }

	if product.Vendor != "" {
		for i := range sellers {
			if sellers[i].Url == product.Vendor {
				createSellerProduct()
				break
			}
		}
	}

}
func createSellerProduct() {
	/*
			Event::dispatch('marketplace.catalog.product.create.before');

		        $sellerProduct = $this->vendorProductRepository->create([
		            'marketplace_seller_id' => $seller_id,
		            'is_approved'           => 1,
		            'condition'             => 'new',
		            'description'           => 'scraped product',
		            'is_owner'              => 1,
		            'product_id'            => $product->id,
		        ]);

		        foreach ($sellerProduct->product->variants as $baseVariant) {
		            $this->vendorProductRepository->create([
		                'parent_id' => $sellerProduct->id,
		                'product_id' => $baseVariant->id,
		                'is_owner' => 1,
		                'marketplace_seller_id' => $seller_id,
		                'is_approved' => 1,
		                'condition' => 'new',
		            ]);
		        }

		        Event::dispatch('marketplace.catalog.product.create.after', $sellerProduct);

		        return $sellerProduct;
	*/
}
func collectAttributes(variant *models.Product, option *gm.AttributeOption) []gm.ProductAttributeValue {
	sku := fmt.Sprintf("%s-%s", variant.ProductGroupID, variant.ProductNumber)
	weight, _ := strconv.ParseFloat(variant.Weight, 64)
	var description string

	for _, desc := range variant.Descriptions {
		description += "<p>" + desc.Description + "</p>"
	}

	return []gm.ProductAttributeValue{
		{AttributeID: attributesMap["sku"].ID, TextValue: sku, Channel: "default", Locale: "tm"},
		{AttributeID: attributesMap["product_number"].ID, TextValue: variant.ProductNumber, Channel: "default", Locale: "tm"},
		{AttributeID: attributesMap["name"].ID, TextValue: variant.Name, Channel: "default", Locale: "tm"},
		{AttributeID: attributesMap["weight"].ID, FloatValue: weight, Channel: "default", Locale: "tm"},
		// {AttributeID: attributesMap["source"].ID, TextValue: variant.URLKey, Channel: "default", Locale: "tm"},
		{AttributeID: attributesMap["status"].ID, BooleanValue: true, Channel: "default", Locale: "tm"},
		{AttributeID: attributesMap["visible_individually"].ID, BooleanValue: true, Channel: "default", Locale: "tm"},
		{AttributeID: attributesMap["url_key"].ID, TextValue: sku, Channel: "default", Locale: "tm"},
		// {AttributeID: attributesMap["favoritesCount"].ID, IntegerValue: variant.FavoriteCount, Channel: "default", Locale: "tm"},
		{AttributeID: attributesMap["description"].ID, TextValue: description, Channel: "default", Locale: "tm"},
		{AttributeID: option.AttributeID, IntegerValue: int(option.ID), Channel: "default", Locale: "tm"},
	}
}

func assignAttributes(productID uint, data *models.Product) []gm.ProductAttributeValue {

	weight, _ := strconv.ParseFloat(data.Weight, 64)

	var description string

	for _, desc := range data.Descriptions {
		description += "<p>" + desc.Description + "</p>"
	}
	//$desc = implode(array_map(fn($value): string => '<p>' . $value['description'] . '</p>', $data['descriptions']));

	var productAttributeValues = []gm.ProductAttributeValue{
		{ProductID: productID, AttributeID: attributesMap["sku"].ID, TextValue: data.ProductGroupID, Channel: "default", Locale: "tm"},
		{ProductID: productID, AttributeID: attributesMap["product_number"].ID, TextValue: data.ProductNumber, Channel: "default", Locale: "tm"},
		{ProductID: productID, AttributeID: attributesMap["name"].ID, TextValue: data.Name, Channel: "default", Locale: "tm"},
		{ProductID: productID, AttributeID: attributesMap["weight"].ID, FloatValue: weight, Channel: "default", Locale: "tm"},
		// {ProductID: productID, AttributeID: attributesMap["source"].ID, TextValue: data.URLKey, Channel: "default", Locale: "tm"},
		{ProductID: productID, AttributeID: attributesMap["status"].ID, BooleanValue: true, Channel: "default", Locale: "tm"},
		{ProductID: productID, AttributeID: attributesMap["visible_individually"].ID, BooleanValue: true, Channel: "default", Locale: "tm"},
		{ProductID: productID, AttributeID: attributesMap["url_key"].ID, TextValue: data.ProductGroupID, Channel: "default", Locale: "tm"},
		// {ProductID: productID, AttributeID: attributesMap["short_description"].ID, TextValue: description, Channel: "default", Locale: "tm"},
		{ProductID: productID, AttributeID: attributesMap["description"].ID, TextValue: description, Channel: "default", Locale: "tm"},
		// {ProductID: productID, AttributeID: attributesMap["favoritesCount"].ID, IntegerValue: data.FavoriteCount, Channel: "default", Locale: "tm"},
	}

	// if data.Price.OriginalPrice.Value > data.Price.DiscountedPrice.Value {
	// 	productAttributeValues = append(productAttributeValues, []gm.ProductAttributeValue{
	// 		{ProductID: productID, AttributeID: attributesMap["price"].ID, FloatValue: data.Price.OriginalPrice.Value, Channel: "default", Locale: "tm"},
	// 		{ProductID: productID, AttributeID: attributesMap["special_price"].ID, FloatValue: data.Price.DiscountedPrice.Value, Channel: "default", Locale: "tm"},
	// 	}...)

	// } else {
	// 	productAttributeValues = append(productAttributeValues, gm.ProductAttributeValue{ProductID: productID, AttributeID: attributesMap["price"].ID, FloatValue: data.Price.OriginalPrice.Value, Channel: "default", Locale: "tm"})

	// }

	return productAttributeValues
}

func getPriceAttributes(productID uint, price *models.Price) []gm.ProductAttributeValue {
	var productAttributeValues []gm.ProductAttributeValue
	if price.OriginalPrice.Value > price.DiscountedPrice.Value {
		productAttributeValues = []gm.ProductAttributeValue{
			{ProductID: productID, AttributeID: attributesMap["price"].ID, FloatValue: price.OriginalPrice.Value, Channel: "default", Locale: "tm"},
			{ProductID: productID, AttributeID: attributesMap["special_price"].ID, FloatValue: price.DiscountedPrice.Value, Channel: "default", Locale: "tm"},
		}

	} else {
		productAttributeValues = []gm.ProductAttributeValue{{ProductID: productID, AttributeID: attributesMap["price"].ID, FloatValue: price.OriginalPrice.Value, Channel: "default", Locale: "tm"}}

	}

	return productAttributeValues
}

func getAttributeFamily() gm.AttributeFamily {

	return families[0]
}