package blockchain

import (
	"context"
	"fmt"
	"github.com/fonchain_enterprise/fonchain-main/api/account"
	"github.com/fonchain_enterprise/fonchain-main/api/e_card"
	"github.com/fonchain_enterprise/fonchain-main/api/equity"
	"github.com/fonchain_enterprise/fonchain-main/api/rule"
	"github.com/fonchain_enterprise/fonchain-main/pkg/e"
	"github.com/fonchain_enterprise/fonchain-main/pkg/model/request"
	"github.com/fonchain_enterprise/fonchain-main/pkg/response"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service"
	"github.com/gin-gonic/gin"
)

// BlockUserList 用户列表
func BlockUserList(ctx *gin.Context) {
	req := &request.BlockUserListReq{}
	resp := &response.BlockUserListResp{}
	var err error
	if err = ctx.ShouldBind(&req); err != nil {
		service.ResponseQuickMsg(ctx, e.Failed, err.Error(), nil)
		return
	}
	status := ""
	if req.Status == 1 {
		status = "notactive"
	} else if req.Status == 2 {
		status = "left"
	}
	userReq := &account.ListRequest{
		Domain:         "blockchain",
		PageSize:       req.PageSize,
		Page:           req.Page,
		Key:            req.Name,
		TelNum:         req.TelNum,
		Status:         status,
		StartEnterDate: req.StartDate,
		EndEnterDate:   req.EndDate,
	}
	res, err := service.AccountProvider.List(ctx, userReq)
	if err != nil {
		service.ResponseQuickMsg(ctx, e.Failed, err.Error(), nil)
		return
	}

	// 一次性分配 UserId 切片的空间
	UserId := make([]int32, 0, len(res.Data))
	for _, v := range res.Data {
		UserId = append(UserId, int32(v.ID))
	}
	// 获取余额
	rep, err := service.EquityProvider.GetResourcesByUserIds(ctx, &equity.GetResourcesByUserIdsRequest{
		UserIDs: UserId,
	})
	if err != nil {
		service.ResponseQuickMsg(ctx, e.Failed, err.Error(), nil)
		return
	}
	resourcesByUserID := make(map[uint64]*equity.ResourcesByUserID)
	for _, resource := range rep.ResourcesByUserID {
		resourcesByUserID[uint64(resource.UserID)] = resource
	}

	// 处理结果
	for _, v := range res.Data {
		resource, ok := resourcesByUserID[v.ID]
		if !ok {
			// 如果获取不到余额，将余额赋值为0
			resource = &equity.ResourcesByUserID{
				UserID:   int32(v.ID),
				Money:    0,
				Resource: 0,
			}
		}
		resStatus := 0
		switch v.Status {
		case "notactive":
			resStatus = 1
		case "left":
			resStatus = 2
		}
		resp.List = append(resp.List, &response.BlockUserList{
			Id:            v.ID,
			Name:          v.NickName,
			TelNum:        v.TelNum,
			Status:        resStatus,
			RegisterDate:  v.EnterDate,
			IdCard:        v.IDNum,
			BlockAddr:     v.BlockAddr,
			CardBalance:   uint64(resource.Money),
			EquityBalance: uint64(resource.Resource),
		})
	}
	service.ResponseQuickMsg(ctx, e.Success, "success", resp)
	return
}
func BlockUserSetting(ctx *gin.Context) {
	req := &request.BlockUserSettingReq{}
	var err error
	if err = ctx.ShouldBind(&req); err != nil {
		service.ResponseQuickMsg(ctx, e.Failed, err.Error(), nil)
		return
	}
	if len(req.Ids) > 10 || req.Status != 1 && req.Status != 2 {
		service.ResponseQuickMsg(ctx, e.Failed, e.GetMsg(e.InvalidParams), nil)
		return
	}
	status := ""
	switch req.Status {
	case 1:
		status = "notactive"
	case 2:
		status = "left"
	}
	for _, i := range req.Ids {
		_, err = service.AccountProvider.Update(ctx, &account.UpdateRequest{
			ID:     i,
			Domain: "blockchian",
			Status: status,
		})
		if err != nil {
			service.ResponseQuickMsg(ctx, e.Failed, err.Error(), nil)
			return
		}
	}
	service.ResponseQuickMsg(ctx, e.Success, "success", nil)
	return

}

func AddChain(c *gin.Context) {
	var addChainRequest e_card.AddChainRequest
	if err := c.ShouldBind(&addChainRequest); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	rep, err := service.ECardProvider.AddChain(context.Background(), &addChainRequest)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, rep)

	return

}

func ECardUserManage(c *gin.Context) {
	var eCardUserManageRequest e_card.ECardUserManageRequest
	if err := c.ShouldBind(&eCardUserManageRequest); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	rep, err := service.ECardProvider.ECardUserManage(context.Background(), &eCardUserManageRequest)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, rep)

	return

}

func ChainRecord(c *gin.Context) {
	var chainRecordRequest e_card.ChainRecordRequest
	if err := c.ShouldBind(&chainRecordRequest); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	rep, err := service.ECardProvider.ChainRecord(context.Background(), &chainRecordRequest)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, rep)

	return

}

func SaveInfo(c *gin.Context) {
	res, err := service.AccountProvider.List(context.Background(), &account.ListRequest{Domain: "fontree", PageSize: 99999, Page: 1, Status: "notactive"})
	if err != nil {
		fmt.Println("获取用户信息失败", err)
		return
	}

	for _, data := range res.Data {
		// 获取岗位信息
		uReq := rule.RulesRequest{
			Domain:    "fontree",
			AccountID: data.ID,
		}
		posResp, err := service.RuleProvider.UserInfo(context.Background(), &uReq)
		if err != nil {
			fmt.Println("获取用户信息失败", err)
			service.Error(c, e.Error, err)
			return
		}

		var department []string
		var post []string

		for _, position := range posResp.PositionUsers {
			department = append(department, position.DepartmentName)
			post = append(post, position.PositionName)
		}

		addChainRequest := &e_card.AddChainRequest{
			Name:         data.NickName,
			Phone:        data.TelNum,
			Company:      "泰丰国际",
			Department:   department,
			Post:         post,
			DateOnBoard:  data.EnterDate,
			UserID:       int32(data.ID),
			Addr:         data.Account,
			ChangedPlace: "新建电子名片",
		}
		_, err = service.ECardProvider.AddChain(context.Background(), addChainRequest)
		if err != nil {
			service.Error(c, e.Error, err)
			return
		}
	}

	return
}

func UserExist(c *gin.Context) {
	var userByTelRequest account.UserByTelRequest
	if err := c.ShouldBind(&userByTelRequest); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}
	rep, err := service.AccountProvider.UserByTel(c, &userByTelRequest)
	if err != nil {
		return
	}

	service.Success(c, rep)
}

func Send(c *gin.Context) {
	var req account.SendMsgRequest

	if err := c.ShouldBind(&req); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	res, err := service.AccountProvider.SendMsg(context.Background(), &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
	return
}

func Login(c *gin.Context) {
	var loginRequest account.LoginRequest
	if err := c.ShouldBind(&loginRequest); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	rep, err := service.AccountProvider.Login(c, &loginRequest)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, rep)
}

func Check(c *gin.Context) {
	var checkMsgRequest account.CheckMsgRequest
	if err := c.ShouldBind(&checkMsgRequest); err != nil {
		service.Error(c, e.InvalidParams, err)
		return
	}

	rep, err := service.AccountProvider.CheckMsg(c, &checkMsgRequest)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, rep)
}