package tests_test

import (
	"errors"
	"reflect"
	"strings"
	"testing"

	"gorm.io/gorm"
	. "gorm.io/gorm/utils/tests"
)

type Product struct {
	gorm.Model
	Name                  string
	Code                  string
	Price                 float64
	AfterFindCallTimes    int64
	BeforeCreateCallTimes int64
	AfterCreateCallTimes  int64
	BeforeUpdateCallTimes int64
	AfterUpdateCallTimes  int64
	BeforeSaveCallTimes   int64
	AfterSaveCallTimes    int64
	BeforeDeleteCallTimes int64
	AfterDeleteCallTimes  int64
}

func (s *Product) BeforeCreate(tx *gorm.DB) (err error) {
	if s.Code == "Invalid" {
		err = errors.New("invalid product")
	}
	s.BeforeCreateCallTimes = s.BeforeCreateCallTimes + 1
	return
}

func (s *Product) BeforeUpdate(tx *gorm.DB) (err error) {
	if s.Code == "dont_update" {
		err = errors.New("can't update")
	}
	s.BeforeUpdateCallTimes = s.BeforeUpdateCallTimes + 1
	return
}

func (s *Product) BeforeSave(tx *gorm.DB) (err error) {
	if s.Code == "dont_save" {
		err = errors.New("can't save")
	}
	s.BeforeSaveCallTimes = s.BeforeSaveCallTimes + 1
	return
}

func (s *Product) AfterFind(tx *gorm.DB) (err error) {
	s.AfterFindCallTimes = s.AfterFindCallTimes + 1
	return
}

func (s *Product) AfterCreate(tx *gorm.DB) (err error) {
	return tx.Model(s).UpdateColumn("AfterCreateCallTimes", s.AfterCreateCallTimes+1).Error
}

func (s *Product) AfterUpdate(tx *gorm.DB) (err error) {
	s.AfterUpdateCallTimes = s.AfterUpdateCallTimes + 1
	return
}

func (s *Product) AfterSave(tx *gorm.DB) (err error) {
	if s.Code == "after_save_error" {
		err = errors.New("can't save")
	}
	s.AfterSaveCallTimes = s.AfterSaveCallTimes + 1
	return
}

func (s *Product) BeforeDelete(tx *gorm.DB) (err error) {
	if s.Code == "dont_delete" {
		err = errors.New("can't delete")
	}
	s.BeforeDeleteCallTimes = s.BeforeDeleteCallTimes + 1
	return
}

func (s *Product) AfterDelete(tx *gorm.DB) (err error) {
	if s.Code == "after_delete_error" {
		err = errors.New("can't delete")
	}
	s.AfterDeleteCallTimes = s.AfterDeleteCallTimes + 1
	return
}

func (s *Product) GetCallTimes() []int64 {
	return []int64{s.BeforeCreateCallTimes, s.BeforeSaveCallTimes, s.BeforeUpdateCallTimes, s.AfterCreateCallTimes, s.AfterSaveCallTimes, s.AfterUpdateCallTimes, s.BeforeDeleteCallTimes, s.AfterDeleteCallTimes, s.AfterFindCallTimes}
}

func TestRunCallbacks(t *testing.T) {
	DB.Migrator().DropTable(&Product{})
	DB.AutoMigrate(&Product{})

	p := Product{Code: "unique_code", Price: 100}
	DB.Save(&p)

	if !reflect.DeepEqual(p.GetCallTimes(), []int64{1, 1, 0, 1, 1, 0, 0, 0, 0}) {
		t.Fatalf("Callbacks should be invoked successfully, %v", p.GetCallTimes())
	}

	DB.Where("Code = ?", "unique_code").First(&p)
	if !reflect.DeepEqual(p.GetCallTimes(), []int64{1, 1, 0, 1, 0, 0, 0, 0, 1}) {
		t.Fatalf("After callbacks values are not saved, %v", p.GetCallTimes())
	}

	p.Price = 200
	DB.Save(&p)
	if !reflect.DeepEqual(p.GetCallTimes(), []int64{1, 2, 1, 1, 1, 1, 0, 0, 1}) {
		t.Fatalf("After update callbacks should be invoked successfully, %v", p.GetCallTimes())
	}

	var products []Product
	DB.Find(&products, "code = ?", "unique_code")
	if products[0].AfterFindCallTimes != 2 {
		t.Fatalf("AfterFind callbacks should work with slice, called %v", products[0].AfterFindCallTimes)
	}

	DB.Where("Code = ?", "unique_code").First(&p)
	if !reflect.DeepEqual(p.GetCallTimes(), []int64{1, 2, 1, 1, 0, 0, 0, 0, 2}) {
		t.Fatalf("After update callbacks values are not saved, %v", p.GetCallTimes())
	}

	DB.Delete(&p)
	if !reflect.DeepEqual(p.GetCallTimes(), []int64{1, 2, 1, 1, 0, 0, 1, 1, 2}) {
		t.Fatalf("After delete callbacks should be invoked successfully, %v", p.GetCallTimes())
	}

	if DB.Where("Code = ?", "unique_code").First(&p).Error == nil {
		t.Fatalf("Can't find a deleted record")
	}
}

func TestCallbacksWithErrors(t *testing.T) {
	DB.Migrator().DropTable(&Product{})
	DB.AutoMigrate(&Product{})

	p := Product{Code: "Invalid", Price: 100}
	if DB.Save(&p).Error == nil {
		t.Fatalf("An error from before create callbacks happened when create with invalid value")
	}

	if DB.Where("code = ?", "Invalid").First(&Product{}).Error == nil {
		t.Fatalf("Should not save record that have errors")
	}

	if DB.Save(&Product{Code: "dont_save", Price: 100}).Error == nil {
		t.Fatalf("An error from after create callbacks happened when create with invalid value")
	}

	p2 := Product{Code: "update_callback", Price: 100}
	DB.Save(&p2)

	p2.Code = "dont_update"
	if DB.Save(&p2).Error == nil {
		t.Fatalf("An error from before update callbacks happened when update with invalid value")
	}

	if DB.Where("code = ?", "update_callback").First(&Product{}).Error != nil {
		t.Fatalf("Record Should not be updated due to errors happened in before update callback")
	}

	if DB.Where("code = ?", "dont_update").First(&Product{}).Error == nil {
		t.Fatalf("Record Should not be updated due to errors happened in before update callback")
	}

	p2.Code = "dont_save"
	if DB.Save(&p2).Error == nil {
		t.Fatalf("An error from before save callbacks happened when update with invalid value")
	}

	p3 := Product{Code: "dont_delete", Price: 100}
	DB.Save(&p3)
	if DB.Delete(&p3).Error == nil {
		t.Fatalf("An error from before delete callbacks happened when delete")
	}

	if DB.Where("Code = ?", "dont_delete").First(&p3).Error != nil {
		t.Fatalf("An error from before delete callbacks happened")
	}

	p4 := Product{Code: "after_save_error", Price: 100}
	DB.Save(&p4)
	if err := DB.First(&Product{}, "code = ?", "after_save_error").Error; err == nil {
		t.Fatalf("Record should be reverted if get an error in after save callback")
	}

	p5 := Product{Code: "after_delete_error", Price: 100}
	DB.Save(&p5)
	if err := DB.First(&Product{}, "code = ?", "after_delete_error").Error; err != nil {
		t.Fatalf("Record should be found")
	}

	DB.Delete(&p5)
	if err := DB.First(&Product{}, "code = ?", "after_delete_error").Error; err != nil {
		t.Fatalf("Record shouldn't be deleted because of an error happened in after delete callback")
	}
}

type Product2 struct {
	gorm.Model
	Name  string
	Code  string
	Price int64
	Owner string
}

func (s Product2) BeforeCreate(tx *gorm.DB) (err error) {
	if !strings.HasSuffix(s.Name, "_clone") {
		newProduft := s
		newProduft.Price *= 2
		newProduft.Name += "_clone"
		err = tx.Create(&newProduft).Error
	}

	if s.Name == "Invalid" {
		return errors.New("invalid")
	}

	return nil
}

func (s *Product2) BeforeUpdate(tx *gorm.DB) (err error) {
	tx.Statement.Where("owner != ?", "admin")
	return
}

func TestUseDBInHooks(t *testing.T) {
	DB.Migrator().DropTable(&Product2{})
	DB.AutoMigrate(&Product2{})

	product := Product2{Name: "Invalid", Price: 100}

	if err := DB.Create(&product).Error; err == nil {
		t.Fatalf("should returns error %v when creating product, but got nil", err)
	}

	product2 := Product2{Name: "Nice", Price: 100}

	if err := DB.Create(&product2).Error; err != nil {
		t.Fatalf("Failed to create product, got error: %v", err)
	}

	var result Product2
	if err := DB.First(&result, "name = ?", "Nice").Error; err != nil {
		t.Fatalf("Failed to query product, got error: %v", err)
	}

	var resultClone Product2
	if err := DB.First(&resultClone, "name = ?", "Nice_clone").Error; err != nil {
		t.Fatalf("Failed to find cloned product, got error: %v", err)
	}

	result.Price *= 2
	result.Name += "_clone"
	AssertObjEqual(t, result, resultClone, "Price", "Name")

	DB.Model(&result).Update("Price", 500)
	var result2 Product2
	DB.First(&result2, "name = ?", "Nice")

	if result2.Price != 500 {
		t.Errorf("Failed to update product's price, expects: %v, got %v", 500, result2.Price)
	}

	product3 := Product2{Name: "Nice2", Price: 600, Owner: "admin"}
	if err := DB.Create(&product3).Error; err != nil {
		t.Fatalf("Failed to create product, got error: %v", err)
	}

	var result3 Product2
	if err := DB.First(&result3, "name = ?", "Nice2").Error; err != nil {
		t.Fatalf("Failed to query product, got error: %v", err)
	}

	DB.Model(&result3).Update("Price", 800)
	var result4 Product2
	DB.First(&result4, "name = ?", "Nice2")

	if result4.Price != 600 {
		t.Errorf("Admin product's price should not be changed, expects: %v, got %v", 600, result4.Price)
	}
}

type Product3 struct {
	gorm.Model
	Name  string
	Code  string
	Price int64
	Owner string
}

func (s Product3) BeforeCreate(tx *gorm.DB) (err error) {
	tx.Statement.SetColumn("Price", s.Price+100)
	return nil
}

func (s Product3) BeforeUpdate(tx *gorm.DB) (err error) {
	if tx.Statement.Changed() {
		tx.Statement.SetColumn("Price", s.Price+10)
	}

	if tx.Statement.Changed("Code") {
		s.Price += 20
		tx.Statement.SetColumn("Price", s.Price+30)
	}
	return nil
}

func TestSetColumn(t *testing.T) {
	DB.Migrator().DropTable(&Product3{})
	DB.AutoMigrate(&Product3{})

	product := Product3{Name: "Product", Price: 0}
	DB.Create(&product)

	if product.Price != 100 {
		t.Errorf("invalid price after create, got %+v", product)
	}

	DB.Model(&product).Select("code", "price").Updates(map[string]interface{}{"code": "L1212"})

	if product.Price != 150 || product.Code != "L1212" {
		t.Errorf("invalid data after update, got %+v", product)
	}

	// Code not changed, price should not change
	DB.Model(&product).Updates(map[string]interface{}{"Name": "Product New"})

	if product.Name != "Product New" || product.Price != 160 || product.Code != "L1212" {
		t.Errorf("invalid data after update, got %+v", product)
	}

	// Code changed, but not selected, price should not change
	DB.Model(&product).Select("Name", "Price").Updates(map[string]interface{}{"Name": "Product New2", "code": "L1213"})

	if product.Name != "Product New2" || product.Price != 170 || product.Code != "L1212" {
		t.Errorf("invalid data after update, got %+v", product)
	}

	// Code changed, price should changed
	DB.Model(&product).Select("Name", "Code", "Price").Updates(map[string]interface{}{"Name": "Product New3", "code": "L1213"})

	if product.Name != "Product New3" || product.Price != 220 || product.Code != "L1213" {
		t.Errorf("invalid data after update, got %+v", product)
	}

	var result Product3
	DB.First(&result, product.ID)

	AssertEqual(t, result, product)

	// Code changed, price not selected, price should not change
	DB.Model(&product).Select("code").Updates(map[string]interface{}{"name": "L1214"})

	if product.Price != 220 || product.Code != "L1213" {
		t.Errorf("invalid data after update, got %+v", product)
	}

	var result2 Product3
	DB.First(&result2, product.ID)

	AssertEqual(t, result2, product)
}