package controller

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"lims-extend/common"
	"lims-extend/model"
	"lims-extend/response"
	"lims-extend/util"
	"lims-extend/vo"
)

func ShowPlans(c *gin.Context) {
	db := common.GetDB()
	userId := c.Params.ByName("userId")
	var plans []model.Plan
	//db.Model(&model.Plan{}).Where("plan.delete <> 1").Find(&plans)
	db.Model(&model.Plan{}).Joins("left join plan_groups on plan.id = plan_id ").
		Joins("left join group_users on plan_groups.group_id = group_users.group_id").
		Where("user_id = ? and plan.delete <> 1", userId).Distinct().Find(&plans)
	planVos := make([]vo.PlanVo, len(plans))
	//for i, v := range plans {
	//	planVos[i] = vo.PlanVo{
	//		Plan:     v,
	//		IsJoined: IsJoinedInCurrentPlan(userId, v.Id),
	//	}
	//}
	response.Success(c, gin.H{"planlists": planVos}, "success")
}

func ShowPlan(c *gin.Context) {
	planId := c.Params.ByName("planId")
	db := common.GetDB()
	var plan model.Plan
	if err := db.Model(&model.Plan{}).Where("id = ?", planId).First(&plan).Error; err != nil {
		response.Fail(c, nil, "结果不存在")
		return
	}
	if plan.Delete == 1 {
		response.Fail(c, nil, "当前计划已经被删除")
		return
	}

	planVo := vo.PlanVo{
		SendAmount:    GetSendPacketAmount(planId),
		ReceiveAmount: GetRecvPacketAmount(planId),
		ReportAmount:  GetPlanReportAmount(planId),
	}
	response.Success(c, gin.H{
		"plan": planVo,
	}, "success")

}

// TakePlan 领取测试计划并生成测试任务
// 方法 POST
// 传入参数 测试计划ID，提测人ID

func TakePlan(c *gin.Context) {
	planId := c.Params.ByName("planId")
	username := c.Params.ByName("username")

	// 获取测试计划信息
	db := common.GetDB()
	var plan model.Plan
	if err := db.Model(&model.Plan{}).Where("id = ?", planId).First(&plan).Error; err != nil {
		response.Fail(c, nil, "测试计划不存在")
		return
	}
	//   判断测试计划是否被删除
	if plan.Delete == 1 {
		response.Fail(c, nil, "测试计划已被删除")
		return
	}
	// 获取说明文件信息
	var file model.File
	db.Model(&model.File{}).Where("id = ?", plan.StatementFile).First(&file)
	// 获取提测人信息
	var user model.User
	if err := db.Model(&model.User{}).Where("username = ?", username).First(&user).Error; err != nil {
		response.Fail(c, nil, "提测人不存在")
		return
	}
	// 准备任务信息
	task := model.Task{
		ID:             util.GetNextId(db, "task"),
		Title:          plan.Title + "_" + user.Username,
		State:          0,
		Description:    plan.Description,
		StateFile:      plan.StatementFile,
		CaseFile:       "",
		CaseAll:        0,
		CaseNotExecute: 0,
		CaseSuccess:    0,
		CaseFail:       0,
		CreatedAt:      model.Time{},
		UpdatedAt:      model.Time{},
		Delete:         0,
		PlanId:         plan.Id,
		ExecutorId:     user.ID,
	}

	// 判断任务是否被重复领取
	var dupTask model.Task
	db.Model(&model.Task{}).Where("title = ?", task.Title).First(&dupTask)
	if dupTask.Title != "" {
		response.Fail(c, nil, user.Name+"已领取当前测试任务，请勿重复领取")
		return
	}

	// 从数据库中创建task信息
	if err := db.Create(&task).Error; err != nil {
		response.Fail(c, nil, "测试任务创建失败")
		return
	}

	response.Success(c, gin.H{"task": task}, "success")
}

// AssignPlan 分配指定Plan给GroupList
// 方法 POST
// 传入参数 测试计划ID、GroupIdList
func AssignPlan(c *gin.Context) {
	// 获取planId 以及 groupIdList
	var groupVo vo.GroupVo
	c.ShouldBind(&groupVo)

	db := common.GetDB()
	// 检查plan是否存在
	var plan model.Plan
	if err := db.Model(&model.Plan{}).Where("id = ?", groupVo.PlanId).First(&plan).Error; err != nil {
		response.Fail(c, nil, "计划不存在")
		return
	}
	if plan.Delete == 1 {
		response.Fail(c, nil, "当前计划已经被删除")
		return
	}
	// 检查groupList中group是否存在/被删除
	for _, groupId := range groupVo.GroupIdList {
		var group model.Group
		if err := db.Model(&model.Group{}).Where("id = ?", groupId).First(&group).Error; err != nil {
			response.Fail(c, nil, fmt.Sprintf("团队ID[%s]不存在", groupId))
			return
		}
		// 判断group是否被删除
		if group.Delete == 1 {
			response.Fail(c, nil, fmt.Sprintf("团队ID[%s]已被删除", groupId))
			return
		}
	}

	// 错误信息列表
	var errorTaskLists []string

	// 向group分配plan
	for _, groupId := range groupVo.GroupIdList {
		plan2group := model.Plan2Group{
			PlanId:  groupVo.PlanId,
			GroupId: groupId,
		}

		// 重复分配校验
		if err := db.Model(&model.Plan2Group{}).Where("group_id = ? and plan_id = ?", groupId, groupVo.PlanId).
			First(&model.Plan2Group{}).Error; err == nil {
			response.Fail(c, nil, "分配失败，小组已被该计划分配")
			return
		}

		if err := db.Model(&model.Plan2Group{}).Create(&plan2group).Error; err != nil {
			response.Fail(c, nil, "分配失败")
			return
		}

		// 向组内的人员分配Task实体
		// 获取组内人员ID列表
		var group2users []model.Group2Users
		db.Model(&model.Group2Users{}).Where("group_id = ?", groupId).Find(&group2users)
		for _, item := range group2users {
			// 准备任务信息
			task := model.Task{
				ID:             util.GetNextId(db, "task"),
				Title:          plan.Title,
				State:          3, //待领取状态
				Description:    plan.Description,
				StateFile:      plan.StatementFile,
				CaseFile:       "",
				CaseAll:        0,
				CaseNotExecute: 0,
				CaseSuccess:    0,
				CaseFail:       0,
				CreatedAt:      model.Time{},
				UpdatedAt:      model.Time{},
				Delete:         0,
				PlanId:         plan.Id,
				ExecutorId:     item.UserId,
				CompanyId:      groupVo.CompanyId,
			}

			// 判断任务是否被重复分配, 同时生成分配失败的Task的错误列表及其错误信息
			var dupTask model.Task

			db.Model(&model.Task{}).Where("plan_id = ? and executor_id = ?", plan.Id, item.UserId).First(&dupTask)
			if dupTask.Title != "" {
				errorTaskLists = append(errorTaskLists, fmt.Sprintf("用户ID[%s]已被分配当前测试任务", item.UserId))
				continue
			}

			// 正式开始从数据库中创建Task表项, 并记录错误信息
			if err := db.Create(&task).Error; err != nil {
				errorTaskLists = append(errorTaskLists, fmt.Sprintf("用户ID为[%s]的测试任务创建失败，未知数据库错误", item.UserId))
				continue
			}
		}

	}
	response.Success(c, gin.H{
		"groupIdList": groupVo,
		"errorList":   errorTaskLists,
	}, "分配成功")
}

// GetPlanAssignedGroups 获取指定Plan被分配的小组信息
// 方法 GET
// 传入参数 测试计划ID
func GetPlanAssignedGroups(c *gin.Context) {
	db := common.GetDB()
	planId := c.Params.ByName("planId")
	var plan2groups []model.Plan2Group
	db.Model(&model.Plan2Group{}).Where("plan_id = ?", planId).Find(&plan2groups)

	var groupList []model.Group
	for _, group := range plan2groups {
		var singleGroup model.Group
		db.Model(&model.Group{}).Where("id = ?", group.GroupId).First(&singleGroup)
		groupList = append(groupList, singleGroup)
	}

	response.Success(c, gin.H{"groupList": groupList}, "success")

}

func Test(c *gin.Context) {

	response.Success(c, gin.H{"count": GetPlanReportAmount("TestLaboratory_V1_Plan_9")}, "success")
}

// GetPlanTotalUserAmount 获取当前计划总发包数
// 需要参数planId

func GetSendPacketAmount(planId string) int {
	db := common.GetDB()
	var amount int64
	db.Model(&model.Task{}).Where("plan_id = ?", planId).Count(&amount)
	return int(amount)
}

func GetRecvPacketAmount(planId string) int {
	db := common.GetDB()
	var amount int64
	db.Model(&model.Task{}).Where("plan_id = ? and state <> 3", planId).Count(&amount)
	return int(amount)
}

func GetPlanReportAmount(planId string) int {
	var count int64
	db := common.GetDB()
	db.Model(&model.Task{}).Where("plan_id = ? and state = 2", planId).Count(&count)
	return int(count)
}

func GetPlanTotalUserAmount(planId string) int {
	totalAmount := 0
	var plan2groups []model.Plan2Group
	db := common.GetDB()
	db.Model(&model.Plan2Group{}).Where("plan_id = ?", planId).Find(&plan2groups)
	for _, group := range plan2groups {
		totalAmount += GetGroupUserAmount(group.GroupId)
	}
	return totalAmount
}

// GetGroupUserAmount 获取当前组总用户数
// 需要参数groupId

func GetGroupUserAmount(groupId string) int {
	var count int64
	db := common.GetDB()
	db.Model(&model.Group2Users{}).Where("group_id = ?", groupId).Count(&count)
	return int(count)
}

// GetGroupUserAmount 获取指定计划对接包数量
// 需要参数groupId

//func GetPlanTaskAmount(planId string) int {
//	var count int64
//	db := common.GetDB()
//	db.Model(&model.Task{}).Where("plan_id = ?", planId).Count(&count)
//	return int(count)
//}
//
//func IsJoinedInCurrentPlan(userId string, planId string) bool {
//	var count int64
//	db := common.GetDB()
//	db.Model(&model.Task{}).Where("plan_id = ? and executor_id = ?", planId, userId).Count(&count)
//	if count > 0 {
//		return true
//	} else {
//		return false
//	}
//}