package logic

import (
	"admin/admin"
	"admin/internal/dao"
	"admin/internal/model"
	"admin/internal/svc"
	"admin/validator"
	"context"
	"fmt"
	"strconv"
	"strings"

	"github.com/zeromicro/go-zero/core/logx"
	"pkg.local/modelbase"
	"pkg.local/utils"
)

type AdminAddLogic struct {
	ctx    context.Context
	svcCtx *svc.ServiceContext
	logx.Logger
	BaseLogic
}

func NewAdminAddLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AdminAddLogic {
	return &AdminAddLogic{
		ctx:    ctx,
		svcCtx: svcCtx,
		Logger: logx.WithContext(ctx),
	}
}

func (l *AdminAddLogic) AdminAdd(in *admin.AdminEditRequest) (*admin.Response, error) {
	var v validator.AdminEditValidator
	if fail := l.checkParams(in, &v); fail != nil {
		return fail, nil
	}

	encryPhone, cErr := utils.EncryptPhone(in.Phone)
	if cErr != nil {
		l.Logger.Error(cErr)
		return l.fail(utils.ErrorEncryptAesError), nil
	}

	info, check := l.checkPhone(encryPhone)
	if !check {
		return l.fail(utils.ErrorEncryptAesError), nil
	}
	modelObj := model.AdminModel{}.Init()
	if in.Id > utils.NumberZero && info.Id < utils.NumberOne {
		w := modelbase.Params{Eq: map[string]string{"id": strconv.Itoa(int(in.Id))}}
		info = dao.Admin{}
		err := modelObj.GetOne(w, &info)
		if err != nil {
			l.Logger.Error(cErr)
			return l.fail(utils.Fail), nil

		}
		if info.Id < utils.NumberZero {
			return l.fail(utils.ErrorNotFund), nil
		}
	}
	//编辑
	if in.Id > utils.NumberZero {
		if info.Id < utils.NumberOne {
			return l.fail(utils.ErrorNotFund), nil
		}
		if info.Id != in.Id {
			return l.fail(utils.ErrorExistUser), nil
		}
	} else {
		if len(in.Password) < utils.NumberOne {
			return l.out(utils.ErrorParams, "密码不能为空"), nil

		}
		if info.Id > utils.NumberZero {
			return l.fail(utils.ErrorExistUser), nil
		}
	}
	//adminId, _ := c.Get(utils.USERID)
	//adminName, _ := c.Get(utils.USERNAME)
	var roles []string
	if len(in.Roles) > utils.NumberZero {
		for _, role := range in.Roles {
			roles = append(roles, strconv.Itoa(int(role)))
		}
	}

	info.Name = in.Name
	info.Phone = encryPhone
	info.Roles = strings.Join(roles, ",")
	info.Email = in.Email
	info.Avatar = in.Avatar
	var err error
	if info.Id > utils.NumberZero {
		w := modelbase.Params{Eq: map[string]string{"id": strconv.Itoa(int(info.Id))}}
		_, err = modelObj.Edit(w, info)
	} else {
		salt := utils.GetRandstring(utils.NumberFive)
		pwd := fmt.Sprintf("%s%s", salt, in.Password)
		pwd, _ = utils.EncryptPassword(pwd)
		info.Password = pwd
		info.Salt = salt
		err = modelObj.Init().Create(&info)
	}

	if err != nil {
		l.Logger.Error(err)
		return l.fail(utils.Fail), nil
	}
	return l.ok(info.Id), nil
}

func (l *AdminAddLogic) checkPhone(phone string) (dao.Admin, bool) {
	w := modelbase.Params{Eq: map[string]string{"phone": phone}}
	info := dao.Admin{}
	err := model.AdminModel{}.Init().GetOne(w, &info)
	if err != nil {
		l.Logger.Error(err)
		return info, false
	}

	return info, true
}