package migrate

import (
	config2 "SciencesServer/app/basic/config"
	"SciencesServer/app/common/model"
	"SciencesServer/utils"
	"fmt"
	"gorm.io/gorm"
)

type Instance struct {
	gormDB *gorm.DB
}

type Option func(instance *Instance)

type synchronized struct {
	iModel  model.IModel
	iValues func() interface{}
	Catch   func() interface{}
}

func (this *Instance) Handle() {
	fmt.Println("========================\n===   数据开始迁移   ===\n========================")

	db := this.gormDB

	successCount, failureCount := 0, 0

	function := func(synchronized ...*synchronized) {
		for _, v := range synchronized {
			if !db.Migrator().HasTable(v.iModel) {
				err := db.Migrator().CreateTable(v.iModel)
				if err != nil {
					failureCount++
				} else {
					successCount++
				}
				if v.iValues != nil && v.iValues() != nil {
					db.Table(v.iModel.TableName()).Create(v.iValues())
				}
			} else if v.Catch != nil && v.Catch() != nil {
				v.Catch()
			}
		}
	}
	function(
		&synchronized{iModel: model.NewSysTenant()}, &synchronized{iModel: model.NewSysTenantMenu()}, &synchronized{iModel: model.NewSysTenantAuth()},
		&synchronized{iModel: model.NewSysConfig()},
		&synchronized{iModel: model.NewSysMenu()}, &synchronized{iModel: model.NewSysAuth()},
		&synchronized{iModel: model.NewSysUser(), iValues: func() interface{} {
			return &model.SysUser{Account: "admin", Name: "商挈智能", Mobile: "13888888888",
				Password: utils.Md5String("123456"),
				IsAdmin:  model.SysUserAdministratorForAdmin, Remark: "超级管理员"}
		}},
		&synchronized{iModel: model.NewSysUserRole()}, &synchronized{iModel: model.NewSysUserTenant()},
		&synchronized{iModel: model.NewSysDepartment()},
		&synchronized{iModel: model.NewSysRole()}, &synchronized{iModel: model.NewSysRoleMenu()}, &synchronized{iModel: model.NewSysRoleAuth()},
		&synchronized{iModel: model.NewSysUserDepartment()},
		// 配置管理
		&synchronized{iModel: model.NewSysConfig(), iValues: func() interface{} {
			return nil
		}},
		&synchronized{iModel: model.NewSysIdentity(), iValues: func() interface{} {
			out := make([]*model.SysIdentity, 0)

			for k, v := range config2.TenantUserIdentityData {
				registerCount := 1

				if k == config2.TenantUserIdentityForCompany {
					registerCount = -1
				}
				out = append(out, &model.SysIdentity{
					Identity:      k,
					Name:          v,
					RegisterCount: registerCount,
					IsExamine:     1,
				})
			}
			return out
		}},
		&synchronized{iModel: model.NewSysIndustry(), iValues: func() interface{} {
			file := "./file/sys_industry.json"
			src := make([]*config2.MemoryForIndustry, 0)
			utils.LoadConfig(file, &src)
			out := make([]*model.SysIndustry, 0)

			var id uint64 = 1

			for _, v := range src {
				var parentID uint64 = 0

				data := &model.SysIndustry{
					Model: model.Model{
						ID: id,
					},
					ParentID: parentID,
					Name:     v.Name,
				}
				out = append(out, data)

				if v.Children != nil && len(v.Children) > 0 {
					parentID = id
					for _, val := range v.Children {
						id++
						data = &model.SysIndustry{
							Model: model.Model{
								ID: id,
							},
							ParentID: parentID,
							Name:     val.Name,
						}
						out = append(out, data)
					}
				}
			}
			return out
		}},
		&synchronized{iModel: model.NewSysNavigation()}, &synchronized{iModel: model.NewSysAbout()},
		&synchronized{iModel: model.NewSysBanner()}, &synchronized{iModel: model.NewSysAgreement()},
		// 日志管理
		&synchronized{iModel: model.NewSysLog()}, &synchronized{iModel: model.NewSysUserLoginLog()},
		&synchronized{iModel: model.NewSysUserExamineLog()},
		// 用户管理
		&synchronized{iModel: model.NewUserInstance()}, &synchronized{iModel: model.NewUserIdentity()},
		&synchronized{iModel: model.NewUserAssets()}, &synchronized{iModel: model.NewUserBank()},
		&synchronized{iModel: model.NewUserCompany()}, &synchronized{iModel: model.NewUserExpert()},
		&synchronized{iModel: model.NewUserLaboratory()}, &synchronized{iModel: model.NewUserResearch()},
		&synchronized{iModel: model.NewUserAgent()},
		&synchronized{iModel: model.NewUserVisit()}, &synchronized{iModel: model.NewUserCollect()},
		// 数据管理
		&synchronized{iModel: model.NewManageCompany()}, &synchronized{iModel: model.NewManageExpert()},
		&synchronized{iModel: model.NewManageLaboratory()}, &synchronized{iModel: model.NewManageResearch()},
		&synchronized{iModel: model.NewManageAgent()},
		&synchronized{iModel: model.NewManageCooperateEnterprise()},
		&synchronized{iModel: model.NewTechnologyAchievement()}, &synchronized{iModel: model.NewTechnologyDemand()},
		&synchronized{iModel: model.NewTechnologyPaper()}, &synchronized{iModel: model.NewTechnologyProduct()},
		&synchronized{iModel: model.NewTechnologyProject()}, &synchronized{iModel: model.NewTechnologyTopic()},
		&synchronized{iModel: model.NewTechnologyDemandService()}, &synchronized{iModel: model.NewTechnologyDemandServiceProgress()},
		&synchronized{iModel: model.NewTechnologyPatent()}, &synchronized{iModel: model.NewTechnologyPatentExpert()}, &synchronized{iModel: model.NewTechnologyPatentClassify()},
		&synchronized{iModel: model.NewServiceDocking()},
		&synchronized{iModel: model.NewServiceMessage()}, &synchronized{iModel: model.NewServiceMessageLog()},
		&synchronized{iModel: model.NewServiceSolutionCase()}, &synchronized{iModel: model.NewServiceSolutionCaseKind()},
		&synchronized{iModel: model.NewServiceInnovate()}, &synchronized{iModel: model.NewServiceInnovateKind()},
		// 活动管理
		&synchronized{iModel: model.NewActivityInstance()}, &synchronized{iModel: model.NewActivityApply()},
		&synchronized{iModel: model.NewActivityApplyLog()}, &synchronized{iModel: model.NewActivityJoin()},
		// 订单管理
		&synchronized{iModel: model.NewOrderInstance()}, &synchronized{iModel: model.NewOrderLog()},
	)
	fmt.Printf("========================\n===  数据完成迁移，成功【%d】，失败【%d】  ===\n========================\n",
		successCount, failureCount)
}

func WithGormDBOption(db *gorm.DB) Option {
	return func(instance *Instance) {
		instance.gormDB = db
	}
}

func NewInstance(options ...Option) *Instance {
	out := new(Instance)

	for _, v := range options {
		v(out)
	}
	return out
}