package company

import (
	"errors"
	"fmt"
	"math/rand"
	"recook/internal/define"
	"recook/internal/libs/aliyun"
	"recook/internal/libs/bean"
	"recook/internal/service/baseCode"
	"recook/internal/v2/model/company"
	"recook/internal/v2/model/recook/manage"
	"recook/internal/v2/model/recook/user"
	"strings"
	"time"

	"git.oa00.com/go/mysql"
	"github.com/golangkit/formatime"
	"gorm.io/gorm"
	"gorm.io/gorm/clause"
)

type logic struct {
}

var Logic = &logic{}

type ArgsCompanyList struct {
	bean.Page
	Name          string `json:"name"`
	Mobile        string `json:"mobile"`
	Contract      string `json:"contract"`
	ApplyUserName string `json:"apply_user_name"`
	State         int    `json:"state"`
	Status        int    `json:"status"`
	Start         string `json:"start"`
	End           string `json:"end"`
}

func (o logic) List(args ArgsCompanyList) (res []company.Info, total int64, err error) {
	query := mysql.Db.Table((&company.Info{}).TableName())
	{
		if args.Name != "" {
			query = query.Where("company_name like ?", fmt.Sprintf("%%%s%%", args.Name))
		}
		if args.Mobile != "" {
			query = query.Where("mobile=?", args.Mobile)
		}
		if args.Contract != "" {
			query = query.Where("contract_name like ?", fmt.Sprintf("%%%s%%", args.Contract))
		}

		if args.Start != "" {
			query = query.Where("created_at > ?", args.Start)
		}
		if args.End != "" {
			query = query.Where("created_at < ?", args.End)
		}
		if args.ApplyUserName != "" {
			sub := mysql.Db.Table((&manage.RecookManageUserInfoModel{}).TableName()).
				Select("id").Where("name like ?", fmt.Sprintf("%%%s%%", args.ApplyUserName))
			query = query.Where("apply_user_id in (?)", sub)
		}
		if args.State != 0 {
			query = query.Where("state = ?", args.State)
		}
	}
	query.Count(&total)
	query.Preload("Logs.ManageUserInfo").
		Preload(clause.Associations).
		Offset(args.GetStart()).Limit(args.GetLimit()).Find(&res)
	for i, v := range res {
		var u1 user.RecookUserInfoModel
		mysql.Db.First(&u1, "id = ?", v.UserID)
		if u1.Id == 0 {
			continue
		}
		mysql.Db.Table(u1.TableName()).Where("root_id = ? and level = 2", u1.Id).Count(&res[i].Count)
	}
	return
}

type ArgsShopList struct {
	bean.Page
	ID     uint   `json:"id"  validate:"required"`
	Name   string `json:"name"`
	Mobile string `json:"mobile"`
	Kind   uint   `json:"kind"`
	Start  string `json:"start"`
	End    string `json:"end"`
}

type ShopEntry struct {
	ID         uint             `json:"id"`
	Name       string           `json:"name"`
	Mobile     string           `json:"mobile"`
	Level      uint             `json:"level"`
	Count      int64            `json:"count"`
	UpdateTime formatime.Second `json:"update_time"`
	Kind       uint             `json:"kind"`
}

func (o logic) ShopList(args ArgsShopList) (res []ShopEntry, total int64, err error) {
	var cm company.Info
	if err = mysql.Db.First(&cm, "id = ?", args.ID).Error; err != nil {
		return
	}

	query := mysql.Db.Table((&user.RecookUserInfoModel{}).TableName()).Where("root_id = ? and level = 2", cm.UserID)
	{
		if args.Name != "" {
			query = query.Where("nickname like ?", fmt.Sprintf("%%%s%%", args.Name))
		}
		if args.Mobile != "" {
			query = query.Where("mobile = ?", args.Mobile)
		}
		switch args.Kind {
		case 1:
			query = query.Where("level = 2 and is_offline = 0")
		case 2:
			query = query.Where("level = 2 and is_offline = 1")
		}

		if args.Start != "" {
			query = query.Where("update_time2 > ?", args.Start)
		}
		if args.End != "" {
			query = query.Where("update_time2 < ?", args.End)
		}
	}
	query.Count(&total)
	temp := make([]user.RecookUserInfoModel, 0)
	query.Limit(args.GetLimit()).Offset(args.GetStart()).Find(&temp)
	for _, v := range temp {
		kind := 1
		if v.IsOffline {
			kind = 2
		}
		obj := ShopEntry{
			ID:         v.Id,
			Name:       v.Nickname,
			Level:      uint(v.Level),
			Count:      0,
			UpdateTime: v.UpgradeTime2,
			Mobile:     v.Mobile,
			Kind:       uint(kind),
		}
		mysql.Db.Table((&user.RecookUserInfoModel{}).TableName()).Where("parent_id = ?", v.Id).Count(&obj.Count)
		res = append(res, obj)
	}
	return
}

func (o logic) MasterList(args ArgsShopList) (res []ShopEntry, total int64, err error) {
	query := mysql.Db.Table((&user.RecookUserInfoModel{}).TableName()).Where("parent_id = ? and level = 1", args.ID)
	{
		if args.Name != "" {
			query = query.Where("nickname like ?", fmt.Sprintf("%%%s%%", args.Name))
		}
		if args.Mobile != "" {
			query = query.Where("mobile = ?", args.Mobile)
		}

		if args.Start != "" {
			query = query.Where("update_time1 > ?", args.Start)
		}
		if args.End != "" {
			query = query.Where("update_time1 < ?", args.End)
		}
	}
	query.Count(&total)
	temp := make([]user.RecookUserInfoModel, 0)
	query.Limit(args.GetLimit()).Offset(args.GetStart()).Find(&temp)
	for _, v := range temp {
		obj := ShopEntry{
			ID:         v.Id,
			Name:       v.Nickname,
			Mobile:     v.Mobile,
			Level:      0,
			Count:      0,
			UpdateTime: v.UpgradeTime1,
		}
		res = append(res, obj)
	}
	return
}

func (o logic) All() (res []string) {
	mysql.Db.Table((&company.Info{}).TableName()).Pluck("company_name", &res)
	return
}

type CompanySureApply struct {
	ID     uint `json:"id" validate:"required"`
	UserID uint `json:"user_id"`
}

func (o logic) Sure(args CompanySureApply) error {
	if err := mysql.Db.Transaction(func(tx *gorm.DB) error {
		var obj company.Info
		if err := tx.First(&obj, "id = ?", args.ID).Error; err != nil {
			return err
		}
		if obj.State != company.Wait {
			return nil
		}
		if err := tx.Model(&obj).Updates(company.Info{
			State:         company.Pass,
			ProcessUserID: args.UserID,
			ProcessTime:   formatime.NewSecondNow(),
			Status:        company.Normal,
		}).Error; err != nil {
			return err
		}
		if err := tx.Create(&company.Log{
			Text:      fmt.Sprintf("审核通过,并创建账号%s", obj.Mobile),
			UserID:    args.UserID,
			CreatedAt: formatime.NewSecondNow(),
			CompanyID: args.ID,
		}).Error; err != nil {
			return err
		}
		var u1 user.RecookUserInfoModel
		if err := tx.First(&u1, "mobile = ?", obj.Mobile).Error; err != nil && err != gorm.ErrRecordNotFound {

			return err
		}
		if u1.Id > 0 {
			return errors.New("手机号已使用")
		}

		mobile := obj.Mobile
		rd := fmt.Sprintf("%06v", rand.New(rand.NewSource(time.Now().UnixNano())).Int31n(1000000))
		sql := `select max(id)+floor(1+rand()*5) from recook_user_info`
		var lastId int64
		if err := tx.Raw(sql).Count(&lastId).Error; err != nil {
			return err
		}
		info := user.RecookUserInfoModel{
			Id:           uint(lastId),
			Nickname:     obj.ShopName,
			Mobile:       mobile,
			Birthday:     formatime.NewSecondFrom(define.DefaultBirthday),
			HeadImgUrl:   "",
			Phone:        mobile,
			Identifier:   time.Now().Format("060102") + rd,
			Level:        10,
			ParentID:     0,
			RootID:       0,
			InvitationNo: baseCode.Encode(uint64(lastId)),
			IsEnterprise: true,
		}

		if err := tx.Create(&info).Error; err != nil {
			tx.Rollback()
			err = fmt.Errorf("创建用户错误101:" + err.Error())
			return err
		}

		//  生成邀请码和推荐码
		info.InvitationNo = baseCode.Encode(uint64(info.Id))
		if err := tx.Save(&info).Error; err != nil {
			err = fmt.Errorf("创建用户错误102:" + err.Error())
			return err
		}
		//	建立钱包
		wallet := user.RecookUserWalletModel{
			UserId: info.Id,
		}
		if err := tx.Create(&wallet).Error; err != nil {
			tx.Rollback()
			err = fmt.Errorf("创建用户错误103:" + err.Error())
			return err
		}
		if err := tx.Model(&obj).Updates(company.Info{
			UserID: uint(lastId),
		}).Error; err != nil {
			return err
		}
		aliyun.Sms.SendMessage(info.Mobile, aliyun.SUCCESS, map[string]string{})
		return nil
	}); err != nil {
		return err
	}
	return nil
}

type CompanyRejectApply struct {
	CompanySureApply
	Reason string `json:"reason" validate:"required,maxLen=20"`
}

func (o logic) Reject(args CompanyRejectApply) error {
	if err := mysql.Db.Transaction(func(tx *gorm.DB) error {
		var obj company.Info
		if err := tx.First(&obj, "id = ?", args.ID).Error; err != nil {
			return err
		}
		if obj.State != company.Wait {
			return nil
		}
		if err := tx.Model(&obj).Updates(company.Info{
			State:         company.Reject,
			ProcessUserID: args.UserID,
			ProcessTime:   formatime.NewSecondNow(),
		}).Error; err != nil {
			return err
		}
		if err := tx.Create(&company.Log{
			Text:      args.Reason,
			UserID:    args.UserID,
			CreatedAt: formatime.NewSecondNow(),
			CompanyID: args.ID,
		}).Error; err != nil {
			return err
		}
		aliyun.Sms.SendMessage(obj.Mobile, aliyun.FAIL, map[string]string{
			"remark": args.Reason,
		})
		return nil
	}); err != nil {
		return err
	}
	return nil
}

type CompanyInfo struct {
	company.Info
	ManageUserID uint `json:"user_id" gorm:"-"`
}

func (o logic) Apply(args CompanyInfo) error {
	if args.ID != 0 {
		if err := mysql.Db.Transaction(func(tx *gorm.DB) error {
			args.Logs = nil
			var c1 company.Info
			mysql.Db.First(&c1, "id=?", args.ID)
			if args.ShopName != c1.ShopName {
				var c2 company.Info
				mysql.Db.First(&c2, "shop_name=?", args.ShopName)
				if c2.ID > 0 {
					return fmt.Errorf("店铺名字已存在")
				}
			}

			if err := tx.Table((&company.Info{}).TableName()).Where("id = ?", args.ID).Updates(args).Error; err != nil {
				return err
			}
			if err := tx.Create(&company.Log{
				Text:      "更新了信息",
				UserID:    args.ManageUserID,
				CreatedAt: formatime.NewSecondNow(),
				CompanyID: args.ID,
			}).Error; err != nil {
				return err
			}
			return nil
		}); err != nil {
			return err
		}
	} else {
		if len(args.Mobile) != 11 || !strings.HasPrefix(args.Mobile, "1") {
			return fmt.Errorf("手机格式不合法")
		}
		var u1 user.RecookUserInfoModel
		mysql.Db.First(&u1, "mobile = ?", args.Mobile)
		if u1.Id > 0 {
			return fmt.Errorf("手机已存在")
		}
		var c1 company.Info
		mysql.Db.First(&c1, "shop_name=?", args.ShopName)
		if c1.ID > 0 {
			return fmt.Errorf("店铺名字已存在")
		}
		args.State = company.Wait
		args.CreatedAt = formatime.NewSecondNow()
		args.Logs = nil
		args.ID = 0
		args.ApplyUserID = args.ManageUserID
		if err := mysql.Db.Transaction(func(tx *gorm.DB) error {
			if err := tx.Create(&args).Error; err != nil {
				return err
			}
			if err := tx.Create(&company.Log{
				Text:      "发起了申请",
				UserID:    args.ManageUserID,
				CreatedAt: formatime.NewSecondNow(),
				CompanyID: args.ID,
			}).Error; err != nil {
				return err
			}

			return nil
		}); err != nil {
			return err
		}
	}

	return nil
}