package department

import (
	"errors"
	"fmt"
	"github.com/fonchain_enterprise/fonchain-main/api/account"
	"github.com/fonchain_enterprise/fonchain-main/pkg/model/login"
	"github.com/jinzhu/copier"

	api "github.com/fonchain_enterprise/fonchain-main/api/department"
	"github.com/fonchain_enterprise/fonchain-main/pkg/config"
	"github.com/fonchain_enterprise/fonchain-main/pkg/e"
	"github.com/fonchain_enterprise/fonchain-main/pkg/model/dto"
	"github.com/fonchain_enterprise/fonchain-main/pkg/model/query"
	"github.com/fonchain_enterprise/fonchain-main/pkg/model/vo"
	"github.com/fonchain_enterprise/fonchain-main/pkg/serializer"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service"
	"github.com/gin-gonic/gin"
	"github.com/gin-gonic/gin/binding"
)

func Create(c *gin.Context) {
	var req api.CreateRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		fmt.Println(err)
		service.Error(c, e.Error, err)
		return
	}

	req.Rules = serializer.GetRulesFormTree(req.DepartmentTreeRule)
	res, err := service.DepartmentProvider.Create(c, &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
}

func GetDepartmentUsersMap(c *gin.Context, userIds []uint64) (map[uint64]string, error) {
	req := api.InfoByUserIdsRequest{
		UserIDs: userIds,
	}

	res, err := service.DepartmentProvider.InfoByUserIds(c, &req)
	if err != nil {
		return nil, err
	}

	return res.DepartmentByUserId, err
}

func Remove(c *gin.Context) {
	var req api.RemoveRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.Error, err)
		return
	}

	res, err := service.DepartmentProvider.Remove(c, &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
}

func Details(c *gin.Context) {
	var req api.DetailsRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.Error, err)
		return
	}

	res, err := service.DepartmentProvider.Details(c, &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
}

func Detail(c *gin.Context) {
	var req api.DetailRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.Error, err)
		return
	}

	res, err := service.DepartmentProvider.Detail(c, &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
}

func RemoveUser(c *gin.Context) {
	var req api.RemoveUserRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.Error, err)
		return
	}

	res, err := service.DepartmentProvider.RemoveUser(c, &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
}

func Update(c *gin.Context) {
	var req api.CreateRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.Error, err)
		return
	}

	req.Rules = serializer.GetRulesFormTree(req.DepartmentTreeRule)

	res, err := service.DepartmentProvider.Update(c, &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
}

func All(c *gin.Context) {
	var req api.BaseAllRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.Error, err)
		return
	}

	res, err := service.DepartmentProvider.BaseAll(c, &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
}

func ListAll(c *gin.Context) {
	var req api.ListRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.Error, err)
		return
	}

	//userInfo := login.GetUserInfoFromC(c)
	//req.LeaderID = userInfo.ID

	res, err := service.DepartmentProvider.List(c, &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
}

func List(c *gin.Context) {
	var req api.ListRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.Error, err)
		return
	}

	userInfo := login.GetUserInfoFromC(c)
	req.LeaderID = userInfo.ID

	res, err := service.DepartmentProvider.List(c, &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
}

func BaseList(c *gin.Context) {
	var qq vo.BaseTreeQ
	var nodes []*dto.Node
	departments := make(map[uint64]struct{})
	if err := c.ShouldBindBodyWith(&qq, binding.JSON); err != nil {
		service.Error(c, e.Error, err)
		return
	}

	req := api.BaseAllRequest{}

	res, err := service.DepartmentProvider.BaseList(c, &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	if qq.IsDepartment == 1 {
		userInfo := login.GetUserInfoFromC(c)
		for _, tt := range userInfo.PositionUsers {
			if tt.DepartmentCode != "admin" {
				departments[tt.DepartmentId] = struct{}{}
			} else {
				departments = make(map[uint64]struct{})
				break
			}
		}
	}

	if res.Data == nil || len(res.Data) == 0 {
		service.Success(c, nodes)
	}

	i := 999999999

	uidMap := make(map[uint64]struct{})

	for _, tt := range res.Data {

		if len(departments) > 0 {
			if _, ok := departments[tt.ID]; ok == false {
				continue
			}
		}

		temp := &dto.Node{
			ID:       uint64(i),
			Name:     tt.Name,
			Children: make([]*dto.Node, 0),
		}
		i++

		for _, ttt := range tt.AllPositions {
			tempPosition := &dto.Node{
				ID:       uint64(i),
				Name:     ttt.Name,
				Children: make([]*dto.Node, 0),
			}
			i++

			for _, tttt := range ttt.Users {
				tempUser := &dto.Node{
					ID:       tttt.UserID,
					Name:     tttt.UserName,
					Children: make([]*dto.Node, 0),
				}

				if _, ok := uidMap[tttt.UserID]; ok == false { //如果不存在
					tempPosition.Children = append(tempPosition.Children, tempUser)
					uidMap[tttt.UserID] = struct{}{}
				}

			}

			temp.Children = append(temp.Children, tempPosition)
		}

		nodes = append(nodes, temp)
	}

	service.Success(c, nodes)
}

func BaseDepartmentList(c *gin.Context) {
	var req api.BaseAllRequest
	var nodes []*dto.Node
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		service.Error(c, e.Error, err)
		return
	}

	res, err := service.DepartmentProvider.BaseList(c, &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	if res.Data == nil || len(res.Data) == 0 {
		service.Success(c, nodes)
	}

	i := 999999999

	for _, tt := range res.Data {
		temp := &dto.Node{
			ID:       uint64(i),
			Name:     tt.Name,
			Children: make([]*dto.Node, 0),
		}
		i++

		for _, ttt := range tt.AllPositions {
			i++

			for _, tttt := range ttt.Users {
				tempUser := &dto.Node{
					ID:       tttt.UserID,
					Name:     tttt.UserName,
					Children: make([]*dto.Node, 0),
				}

				temp.Children = append(temp.Children, tempUser)
			}

			//temp.Children = append(temp.Children, tempPosition)
		}

		nodes = append(nodes, temp)
	}

	service.Success(c, nodes)
}

func SupperUsers(c *gin.Context) {

	var userRes = &account.ListResponse{Count: 0}
	var req = query.UserQuery{}

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

	userInfo := login.GetUserInfoFromC(c)

	dUsersreq := api.UsersRequest{
		ID: userInfo.PositionUsers[0].DepartmentId,
	}

	res, err := service.DepartmentProvider.Users(c, &dUsersreq)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	if res.Count == 0 {
		service.Success(c, nil)
		return
	}

	var userIds []uint64

	for _, tt := range res.Users {
		userIds = append(userIds, tt.UserID)
	}

	IdsReq := account.ListByIDsRequest{
		//IDs:      userIds,
		NickName: req.NickName,
	}
	if userInfo.PositionUsers[0].DepartmentCode != "admin" {
		IdsReq.IDs = userIds
	}

	userRes, userErr := service.AccountProvider.ListByIDs(c, &IdsReq)

	if userErr != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, userRes)
}

func Users(c *gin.Context) {
	var req = api.UsersRequest{}

	userInfo := login.GetUserInfoFromC(c)

	infoReq := api.InfoByUserIdRequest{
		UserID: userInfo.ID,
		Domain: config.Domain,
	}

	infoByUserIdResponse, err1 := service.DepartmentProvider.InfoByUserId(c, &infoReq)

	if err1 != nil {
		service.Error(c, e.Error, err1)
		return
	}

	req.ID = infoByUserIdResponse.DepartmentID

	res, err := service.DepartmentProvider.Users(c, &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	departmentUsers := new(query.DepartmentUsers)
	copier.CopyWithOption(&departmentUsers.Users, res.Users, copier.Option{DeepCopy: true})
	departmentUsers.Count = res.Count

	serializer.BuildUserTel(service.AccountProvider, c, departmentUsers)

	service.Success(c, departmentUsers)
}
func CreateDepartmentHead(c *gin.Context) {
	var req api.CreateDepartmentHeadRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		fmt.Println(err)
		service.Error(c, e.Error, err)
		return
	}

	list, err := service.DepartmentProvider.FindDepartmentHead(c, &api.FindDepartmentHeadRequest{
		StoreId: req.StoreId,
	})
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	if len(list.List) > 0 {
		service.Error(c, e.Error, errors.New("站点已存在"))
		return
	}
	res, err := service.DepartmentProvider.CreateDepartmentHead(c, &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	service.Success(c, res)
	return
}

func UpdateDepartmentHead(c *gin.Context) {
	var req api.CreateDepartmentHeadRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		fmt.Println(err)
		service.Error(c, e.Error, err)
		return
	}

	list, err := service.DepartmentProvider.FindDepartmentHead(c, &api.FindDepartmentHeadRequest{
		StoreId: req.StoreId,
	})
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	if len(list.List) == 0 {
		service.Error(c, e.Error, errors.New("站点不存在"))
		return
	}
	res, err := service.DepartmentProvider.UpdateDepartmentHead(c, &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	service.Success(c, res)
	return
}

func FindDepartmentHeadList(c *gin.Context) {
	var req api.FindDepartmentHeadRequest
	if err := c.ShouldBindBodyWith(&req, binding.JSON); err != nil {
		fmt.Println(err)
		service.Error(c, e.Error, err)
		return
	}
	res, err := service.DepartmentProvider.FindDepartmentHead(c, &req)
	if err != nil {
		service.Error(c, e.Error, err)
		return
	}
	service.Success(c, res)
	return
}