package public_platoon

import (
	"applet/app/db"
	"applet/app/e"
	md "applet/app/md/institutional_management/public_platoon"
	svc "applet/app/svc/public_platoon"
	"code.fnuoos.com/EggPlanet/egg_models.git/src/implement"
	"code.fnuoos.com/EggPlanet/egg_models.git/src/model"
	"errors"
	"github.com/gin-gonic/gin"
	"time"
)

// GetPublicPlatoonBasic
// @Summary      制度中心-公排管理-公排基础设置(获取)
// @Tags         公排管理
// @Description  公排基础设置(获取)
// @Accept       json
// @Produce      json
// @param Authorization header string true "验证参数Bearer和token空格拼接"
// @Success      200   {object}   md.GetPublicPlatoonBasicResp "具体数据"
// @Failure      400   {object}   md.Response              	"具体错误"
// @Router       /api/publicPlatoon/getBasic [get]
func GetPublicPlatoonBasic(c *gin.Context) {
	publicPlatoonBasicDb := implement.NewPublicPlatoonBasicSettingDb(db.Db)
	publicPlatoonBasic, err := publicPlatoonBasicDb.PublicPlatoonBasicSettingGetOne()
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err)
		return
	}
	now := time.Now()
	if publicPlatoonBasic == nil {
		publicPlatoonBasic = &model.PublicPlatoonBasicSetting{
			IsOpen:                     1,
			OriginatorUid:              0,
			SeveralTimes:               0,
			SeveralRows:                0,
			SystemPunishReplace:        0,
			SystemPunishReplaceValue:   0,
			IsSelfActiveGetTeamRevenue: 0,
			CreateAt:                   now.Format("2006-01-02 15:04:05"),
			UpdateAt:                   now.Format("2006-01-02 15:04:05"),
		}
		_, err1 := publicPlatoonBasicDb.PublicPlatoonBasicSettingInsert(publicPlatoonBasic)
		if err1 != nil {
			e.OutErr(c, e.ERR_DB_ORM, err1.Error())
			return
		}

	}
	var resp md.GetPublicPlatoonBasicResp
	resp = md.GetPublicPlatoonBasicResp{
		IsOpen:                     publicPlatoonBasic.IsOpen,
		OriginatorUid:              publicPlatoonBasic.OriginatorUid,
		SeveralTimes:               publicPlatoonBasic.SeveralTimes,
		SeveralRows:                publicPlatoonBasic.SeveralRows,
		SystemPunishReplace:        publicPlatoonBasic.SystemPunishReplace,
		SystemPunishReplaceValue:   publicPlatoonBasic.SystemPunishReplaceValue,
		IsSelfActiveGetTeamRevenue: publicPlatoonBasic.IsSelfActiveGetTeamRevenue,
	}

	e.OutSuc(c, resp, nil)
}

// UpdatePublicPlatoonBasic
// @Summary      制度中心-公排管理-公排基础设置(修改)
// @Tags         公排管理
// @Description  公排基础设置(修改)
// @Accept       json
// @Produce      json
// @param Authorization header string true "验证参数Bearer和token空格拼接"
// @Param        req 	body      interface{}          true   "公排设置表单内容"
// @Success      200   {string}  				"success"
// @Failure      400   {object}   md.Response              	"具体错误"
// @Router       /api/publicPlatoon/getBasic [post]
func UpdatePublicPlatoonBasic(c *gin.Context) {
	var req *md.UpdatePublicPlatoonBasicReq
	if err := c.ShouldBindJSON(&req); err != nil {
		e.OutErr(c, e.ERR_INVALID_ARGS, err)
		return
	}

	publicPlatoonBasicDb := implement.NewPublicPlatoonBasicSettingDb(db.Db)

	publicPlatoonBasic, err := publicPlatoonBasicDb.PublicPlatoonBasicSettingGetOne()
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err)
		return
	}

	setting := &model.PublicPlatoonBasicSetting{
		Id:                         publicPlatoonBasic.Id,
		IsOpen:                     req.IsOpen,
		OriginatorUid:              req.OriginatorUid,
		SeveralTimes:               req.SeveralTimes,
		SeveralRows:                req.SeveralRows,
		SystemPunishReplace:        req.SystemPunishReplace,
		SystemPunishReplaceValue:   req.SystemPunishReplaceValue,
		IsSelfActiveGetTeamRevenue: req.IsSelfActiveGetTeamRevenue,
		CreateAt:                   "",
		UpdateAt:                   "",
	}

	updateAffected, err := publicPlatoonBasicDb.PublicPlatoonBasicSettingUpdate(publicPlatoonBasic.Id, setting, "")
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err)
		return
	}
	if updateAffected <= 0 {
		e.OutErr(c, e.ERR_DB_ORM, "更新数据表失败")
		return
	}
	e.OutSuc(c, "success", nil)
}

// GetRelationshipMap
// @Summary      制度中心-公排管理-关系分布图(获取)
// @Tags         公排管理
// @Description  关系分布图(获取)
// @Accept       json
// @Produce      json
// @param Authorization header string true "验证参数Bearer和token空格拼接"
// @param phone   query string true "phone"
// @param uid   query string true "uid"
// @Success      200   {object}  md.TreeNode	"具体数据"
// @Failure      400   {object}   md.Response              	"具体错误"
// @Router       /api/publicPlatoon/relationshipMap [get]
func GetRelationshipMap(c *gin.Context) {
	phone := c.Query("phone")
	uid := c.Query("uid")
	userDb := implement.NewUserDb(db.Db)

	userRelationDb := implement.NewPublicPlatoonUserRelationDb(db.Db)
	var relation *model.PublicPlatoonUserRelation
	var err error
	if phone != "" {
		user, err1 := userDb.UserGetOneByParams(map[string]interface{}{
			"key":   "phone",
			"value": phone,
		})
		if err1 != nil {
			e.OutErr(c, e.ERR_DB_ORM, err1.Error())
		}
		relation, err = userRelationDb.PublicPlatoonUserRelationGetOneByParams(map[string]interface{}{
			"key":   "uid",
			"value": user.Id,
		})
	} else if uid != "" {
		relation, err = userRelationDb.PublicPlatoonUserRelationGetOneByParams(map[string]interface{}{
			"key":   "uid",
			"value": uid,
		})
	} else {
		relation, err = userRelationDb.PublicPlatoonUserRelationGetOneByParams(map[string]interface{}{
			"key":   "level_total",
			"value": 1,
		})
		if err != nil {
			e.OutErr(c, e.ERR_DB_ORM, err.Error())
			return
		}
	}

	var list *md.TreeNode
	list, err = svc.GetTrees(db.Db, relation, 3)
	if err != nil {
		e.OutErr(c, e.ERR_DB_ORM, err.Error())
		return
	}

	e.OutSuc(c, list, nil)
}

// FindUserRelationshipMap
// @Summary      制度中心-公排管理-关系分布图(获取指定用户下级)
// @Tags         公排管理
// @Description  关系分布图(获取指定用户下级)
// @Accept       json
// @Produce      json
// @param Authorization header string true "验证参数Bearer和token空格拼接"
// @Param    req    query    public_platoon.FindUserRelationshipMapReq  true  "用户ID"
// @Success      200   {object}  public_platoon.RelationshipMap	"具体数据"
// @Failure      400   {object}   md.Response              	"具体错误"
// @Router       /api/publicPlatoon/findUserRelationshipMap [get]
//func FindUserRelationshipMap(c *gin.Context) {
//	var req *public_platoon.FindUserRelationshipMapReq
//	if err := c.ShouldBindQuery(&req); err != nil {
//		e.OutErr(c, e.ERR_INVALID_ARGS, err)
//		return
//	}
//
//	RelationDb := implement.NewPublicPlatoonUserRelationDb(db.Db)
//	relations, err1 := RelationDb.PublicPlatoonUserRelationFindByUid(req.Uid)
//	if err1 != nil {
//		e.OutErr(c, e.ERR_DB_ORM, err1)
//		return
//	}
//
//	userDb := implement.NewUserDb(db.Db)
//	user, err3 := userDb.UserGetOneById(relations[0].Uid)
//	if err3 != nil {
//		e.OutErr(c, e.ERR_DB_ORM, err3.Error())
//		return
//	}
//	var son []public_platoon.RelationshipMap
//	res := public_platoon.RelationshipMap{
//		AvatarUrl: user.Avatar,
//		Phone:     user.Phone,
//		Nickname:  user.Nickname,
//		Uid:       user.Id,
//		Pid:       relations[0].RecommendUid,
//		Level:     relations[0].Level1,
//		Position:  relations[0].Position1,
//		SystemID:  relations[0].Id,
//		Son:       son,
//	}
//	for i := 1; i < len(relations); i++ {
//		user, err4 := userDb.UserGetOneById(relations[i].Uid)
//		if err4 != nil {
//			e.OutErr(c, e.ERR_DB_ORM, err4.Error())
//			return
//		}
//		node := public_platoon.RelationshipMap{
//			AvatarUrl: user.Avatar,
//			Phone:     user.Phone,
//			Nickname:  user.Nickname,
//			Uid:       user.Id,
//			Pid:       relations[i].RecommendUid,
//			Level:     relations[i].Level1,
//			Position:  relations[i].Position1,
//			SystemID:  relations[i].Id,
//			Son:       nil,
//		}
//		res.Son = append(res.Son, node)
//	}
//	e.OutSuc(c, res, nil)
//}
//
//// FindSubUserRelationshipMap
//// @Summary      制度中心-公排管理-关系分布图(获取指定用户上级)
//// @Tags         公排管理
//// @Description  关系分布图(获取指定用户上级)
//// @Accept       json
//// @Produce      json
//// @param Authorization header string true "验证参数Bearer和token空格拼接"
//// @Param    req    query    public_platoon.FindSubUserRelationshipMapReq  true  "用户ID"
//// @Success      200   {object}  public_platoon.RelationshipMap	"具体数据"
//// @Failure      400   {object}   md.Response              	"具体错误"
//// @Router       /api/publicPlatoon/findSubUserRelationshipMap [get]
//func FindSubUserRelationshipMap(c *gin.Context) {
//	var req *public_platoon.FindSubUserRelationshipMapReq
//	if err := c.ShouldBindQuery(&req); err != nil {
//		e.OutErr(c, e.ERR_INVALID_ARGS, err)
//		return
//	}
//
//	RelationDb := implement.NewPublicPlatoonUserRelationDb(db.Db)
//	sonRelation, err1 := RelationDb.PublicPlatoonUserRelationGetOneByUid(req.Uid)
//	if err1 != nil {
//		e.OutErr(c, e.ERR_DB_ORM, err1)
//		return
//	}
//	parentRelation, err2 := RelationDb.PublicPlatoonUserRelationGetOneByUid(sonRelation.FatherUid1)
//	if err2 != nil {
//		e.OutErr(c, e.ERR_DB_ORM, err2)
//		return
//	}
//
//	userDb := implement.NewUserDb(db.Db)
//	son, err3 := userDb.UserGetOneById(sonRelation.Uid)
//	if err3 != nil {
//		e.OutErr(c, e.ERR_DB_ORM, err3.Error())
//		return
//	}
//
//	parent, err4 := userDb.UserGetOneById(parentRelation.Uid)
//	if err4 != nil {
//		e.OutErr(c, e.ERR_DB_ORM, err4.Error())
//		return
//	}
//
//	var sonNode []public_platoon.RelationshipMap
//	sonNode1 := public_platoon.RelationshipMap{
//		AvatarUrl: son.Avatar,
//		Phone:     son.Phone,
//		Nickname:  son.Nickname,
//		Uid:       son.Id,
//		Pid:       sonRelation.RecommendUid,
//		Level:     sonRelation.Level1,
//		Position:  sonRelation.Position1,
//		SystemID:  sonRelation.Id,
//		Son:       nil,
//	}
//	sonNode = append(sonNode, sonNode1)
//	res := public_platoon.RelationshipMap{
//		AvatarUrl: parent.Avatar,
//		Phone:     parent.Phone,
//		Nickname:  parent.Nickname,
//		Uid:       parent.Id,
//		Pid:       parentRelation.RecommendUid,
//		Level:     parentRelation.Level1,
//		Position:  parentRelation.Position1,
//		SystemID:  parentRelation.Id,
//		Son:       sonNode,
//	}
//	e.OutSuc(c, res, nil)
//}

func ExchangeUserPosition(c *gin.Context) {
	var req *md.ExchangeUserPositionReq
	if err1 := c.ShouldBindJSON(&req); err1 != nil {
		e.OutErr(c, e.ERR_INVALID_ARGS, err1)
		return
	}

	relationDb := implement.NewPublicPlatoonUserRelationDb(db.Db)
	relation1, err2 := relationDb.PublicPlatoonUserRelationGetOneByPosition(req.Position1)
	if err2 != nil {
		e.OutErr(c, e.ERR_DB_ORM, err2)
		return
	}
	if relation1 == nil {
		e.OutErr(c, e.ERR_BAD_REQUEST, errors.New("position_1 位置有误"))
		return
	}

	relation2, err3 := relationDb.PublicPlatoonUserRelationGetOneByPosition(req.Position1)
	if err3 != nil {
		e.OutErr(c, e.ERR_DB_ORM, err3)
		return
	}
	if relation2 == nil {
		e.OutErr(c, e.ERR_BAD_REQUEST, errors.New("position_2 位置有误"))
		return
	}

	if relation1.Uid == 1 || relation2.Uid == 1 {
		e.OutErr(c, e.ERR_BAD_REQUEST, errors.New("创始人位置不能被修改"))
	}

	//uid1 := relation1.Uid
	//uid2 := relation2.Uid
	//recommendUid1 := relation1.RecommendUid
	//recommendUid2 := relation2.RecommendUid
	//relation1.Uid = ""
}