package controller

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

func SubmitCompanyCreateRequest(c *gin.Context) {

	db := common.GetDB()
	db.AutoMigrate(&model.CompanyCreateRequest{})
	// 获取数据
	companyName := c.PostForm("company_name")
	creatorId := c.PostForm("user_id")
	certificateFile, err := c.FormFile("business_license")
	// 数据验证
	if err != nil {
		response.Fail(c, nil, "营业执照上传发生错误")
		return
	}
	logoFile, err := c.FormFile("logo")
	if err != nil {
		response.Fail(c, nil, "公司logo上传发生错误")
		return
	}
	var request model.CompanyCreateRequest
	if err := db.Model(&model.CompanyCreateRequest{}).
		Where("name = ?", companyName).First(&request).Error; err == nil || request.Name != "" {
		response.Fail(c, nil, "该公司已存在，无法重复提交申请")
		return
	}
	timestamp := strconv.FormatInt(time.Now().Unix(), 10)
	// 将获取到的图片文件保存到本地
	logoURL := "files/logo/" + timestamp + "_" + logoFile.Filename
	certificateURL := "files/cert/" + timestamp + "_" + certificateFile.Filename
	err = c.SaveUploadedFile(logoFile, logoURL)
	err = c.SaveUploadedFile(certificateFile, certificateURL)
	baseURL := util.GetHTTPHead()
	if err != nil {
		response.Fail(c, nil, "保存文件出错")
		return
	}

	// 查询创建者信息
	var user model.User
	if err := db.Model(&model.User{}).Where("id = ?", creatorId).First(&user).Error; err != nil {
		response.Fail(c, nil, "用户不存在")
		return
	}

	// 创建公司创建请求实体
	request = model.CompanyCreateRequest{
		Name:           companyName,
		LogoUrl:        baseURL + logoURL,
		CertificateUrl: baseURL + certificateURL,
		State:          0, //状态0表示未审核
		CreatorId:      creatorId,
		CreatorName:    user.Username,
		CreatedAt:      model.Time{},
		UpdatedAt:      model.Time{},
	}

	// 提交至数据库
	if err := db.Model(&model.CompanyCreateRequest{}).Create(&request).Error; err != nil {
		response.Fail(c, nil, "公司创建请求出现问题，请检查")
		return
	}

	// 返回创建成功提醒
	response.Success(c, gin.H{"company": request}, "公司创建请求提交成功，请等待审核！")

}

func GetCompanyCreateRequest(c *gin.Context) {
	db := common.GetDB()
	creatorId := c.Params.ByName("creator_id")
	var request model.CompanyCreateRequest
	if err := db.Model(&model.CompanyCreateRequest{}).
		Where("creator_id = ?", creatorId).First(&request).Error; err != nil {
		response.Fail(c, nil, "查无此创建公司请求")
		return
	}
	response.Success(c, gin.H{"request": request}, "查询成功")
}

func GetCompanyCreateRequestsList(c *gin.Context) {
	db := common.GetDB()
	//creatorId := c.Params.ByName("creator_id")
	var requestList []model.CompanyCreateRequest
	if err := db.Model(&model.CompanyCreateRequest{}).
		Find(&requestList).Error; err != nil {
		response.Fail(c, nil, "查询出错")
		return
	}
	response.Success(c, gin.H{"requestList": requestList}, "查询成功")
}

func RejectCompanyCreateRequest(c *gin.Context) {
	db := common.GetDB()
	requestId := c.Params.ByName("request_id")
	var request model.CompanyCreateRequest

	if err := db.Model(&model.CompanyCreateRequest{}).
		Where("id = ?", requestId).
		First(&request).Error; err != nil {
		response.Fail(c, nil, "该创建请求不存在，请检查！")
		return
	}
	if request.State != 0 {
		response.Fail(c, nil, "该创建请求状态不为【未审核】，无法再次变更状态！")
		return
	}
	request.State = 2
	request.UpdatedAt = model.Time{}
	if err := db.Model(&model.CompanyCreateRequest{}).Where("id = ?", requestId).
		Updates(&request).Error; err != nil {
		response.Fail(c, nil, "拒绝失败，数据库错误！")
		return
	}
	response.Success(c, gin.H{"requestList": request}, "该申请已被驳回！")
}

func AcceptCompanyCreateRequest(c *gin.Context) {
	db := common.GetDB()
	requestId := c.Params.ByName("request_id")
	var request model.CompanyCreateRequest

	if err := db.Model(&model.CompanyCreateRequest{}).
		Where("id = ?", requestId).
		First(&request).Error; err != nil {
		response.Fail(c, nil, "该创建请求不存在，请检查！")
		return
	}
	if request.State != 0 {
		response.Fail(c, nil, "该创建请求状态不为【未审核】，无法再次变更状态！")
		return
	}

	db.AutoMigrate(&model.Company{})
	// 开始创建公司实体
	company := model.Company{
		Name:           request.Name,
		LogoUrl:        request.LogoUrl,
		CertificateUrl: request.CertificateUrl,
		CreatorId:      request.CreatorId,
		CreatorName:    request.CreatorName,
		CreatedAt:      model.Time{},
		UpdatedAt:      model.Time{},
	}
	// 创建公司表数据
	if err := db.Model(&model.Company{}).Create(&company).Error; err != nil {
		response.Fail(c, nil, "公司创建失败，数据库错误。")
		return
	}

	// 设置公司创建申请状态为已同意
	request.State = 1
	request.UpdatedAt = model.Time{}
	if err := db.Model(&model.CompanyCreateRequest{}).Where("id = ?", requestId).
		Updates(&request).Error; err != nil {
		response.Fail(c, nil, "同意申请失败，数据库错误！")
		return
	}

	// 将申请人加入公司中
	admin2user := model.Company2Users{
		CompanyId: company.ID,
		UserId:    company.CreatorId,
		State:     1,
		CreatedAt: model.Time{},
		UpdatedAt: model.Time{},
	}
	if err := db.Model(&model.Company2Users{}).Create(&admin2user).Error; err != nil {
		response.Fail(c, nil, "无法将申请人加入公司列表中，数据库错误！")
		return
	}

	response.Success(c, gin.H{"company": company}, "审批通过！公司创建成功！")
}

func ConfirmRejectCompanyCreateRequest(c *gin.Context) {
	db := common.GetDB()
	requestId := c.Params.ByName("request_id")
	var request model.CompanyCreateRequest
	if err := db.Model(&model.CompanyCreateRequest{}).
		Where("id = ? and state = 2", requestId).First(&request).Error; err != nil {
		response.Fail(c, nil, "创建公司申请不存在或者未被驳回，无法撤回申请")
		return
	}
	if err := db.Model(&model.CompanyCreateRequest{}).Where("id = ?", requestId).Delete(&request).Error; err != nil {
		response.Fail(c, nil, "数据库错误，申请撤回失败")
		return
	}

	response.Success(c, nil, "申请撤回成功！")
}

func ApplyJoinCompany(c *gin.Context) {
	db := common.GetDB()
	db.AutoMigrate(&model.Company2Users{})
	// 获取加入公司请求
	type JoinCompanyRequest struct {
		UserId      string `json:"user_id"`
		CompanyName string `json:"company_name"`
	}
	var request JoinCompanyRequest
	if err := c.ShouldBind(&request); err != nil {
		response.Fail(c, nil, "参数不完整")
		return
	}
	// 查询公司是否存在
	var company model.Company
	if err := db.Model(&model.Company{}).
		Where("name = ?", request.CompanyName).
		First(&company).Error; err != nil {
		response.Fail(c, nil, "公司不存在，请检查")
		return
	}
	// 查询是否重复申请
	var dupRequest model.Company2Users
	if err := db.Model(model.Company2Users{}).Where("user_id = ?", request.UserId).
		First(&dupRequest).Error; err == nil && dupRequest.UserId != "" {
		response.Fail(c, nil, fmt.Sprintf("该申请已经存在，请勿重复提交申请"))
		return
	}
	// 创建申请
	applyRequest := model.Company2Users{
		CompanyId: company.ID,
		UserId:    request.UserId,
		State:     0,
		CreatedAt: model.Time{},
		UpdatedAt: model.Time{},
	}
	if err := db.Model(&model.Company2Users{}).Create(&applyRequest).Error; err != nil {
		response.Fail(c, nil, "申请创建失败，数据库错误")
		return
	}
	// 创建成功，返回结果
	response.Success(c, gin.H{"applyRequest": applyRequest}, "申请成功，请等待审核！")
}

func AcceptJoinCompany(c *gin.Context) {
	db := common.GetDB()
	userId := c.Params.ByName("userId")
	var request model.Company2Users
	if err := db.Model(&model.Company2Users{}).Where("user_id = ?", userId).First(&request).Error; err != nil {
		response.Fail(c, nil, "该用户不存在或没有提交过申请")
		return
	}
	if request.State != 0 {
		response.Fail(c, nil, "无法重复审批申请")
		return
	}
	request.State = 1
	request.UpdatedAt = model.Time{}
	if err := db.Model(&model.Company2Users{}).Where("user_id = ?", userId).Updates(&request).Error; err != nil {
		response.Fail(c, nil, "数据库错误，同意申请失败")
		return
	}
	response.Success(c, nil, "同意申请成功")
}

func RejectJoinCompany(c *gin.Context) {
	db := common.GetDB()
	userId := c.Params.ByName("userId")
	var request model.Company2Users
	if err := db.Model(&model.Company2Users{}).Where("user_id = ?", userId).First(&request).Error; err != nil {
		response.Fail(c, nil, "该用户不存在或没有提交过申请")
		return
	}
	if request.State != 0 {
		response.Fail(c, nil, "无法重复审批申请")
		return
	}
	request.State = 2
	request.UpdatedAt = model.Time{}
	if err := db.Model(&model.Company2Users{}).Where("user_id = ?", userId).Updates(&request).Error; err != nil {
		response.Fail(c, nil, "数据库错误，驳回申请失败")
		return
	}
	response.Success(c, nil, "驳回申请成功")
}

func GetJoinCompanyRequests(c *gin.Context) {
	db := common.GetDB()
	companyId := c.Params.ByName("companyId")

	type result struct {
		model.Company2Users
		CreatorName string `json:"creator_name" gorm:"column:username"`
	}

	var requests []result

	if err := db.Raw("SELECT company_users.id,company_id,username,user_id,"+
		"state,company_users.create_time,company_users.update_time "+
		"FROM `company_users`,`user` WHERE user.id = company_users.user_id and company_id = ?", companyId).
		Find(&requests).Error; err != nil {
		response.Fail(c, nil, "数据库错误")
		return
	}
	response.Success(c, gin.H{"requestList": requests}, "查询成功")
}

func DelCompanyMember(c *gin.Context) {
	db := common.GetDB()
	userId := c.Params.ByName("userId")

	var request model.Company2Users
	if err := db.Model(&model.Company2Users{}).Where("user_id = ?", userId).First(&request).Error; err != nil {
		response.Fail(c, nil, "公司成员不存在，请勿重复删除")
		return
	}

	if err := db.Model(&model.Company2Users{}).Where("user_id = ?", userId).Delete(&request).Error; err != nil {
		response.Fail(c, nil, "数据库错误，删除失败")
		return
	}
	response.Success(c, nil, "删除成功")
}

func GetCompanyMembers(c *gin.Context) {
	db := common.GetDB()
	companyId := c.Params.ByName("companyId")
	type userInfo struct {
		Id       string `json:"id" gorm:"column:"`
		Username string `json:"username"`
		Tel      string `json:"tel"`
		IsLogin  string `json:"is_Login"`
		Identify int    `json:"identify"`
	}
	var users []userInfo

	if err := db.Raw("SELECT user.id,username,tel,is_login,identify from `user`,`company_users` WHERE "+
		"company_users.user_id = user.id and state = 1 and company_id = ?", companyId).Find(&users).Error; err != nil {
		response.Fail(c, nil, "数据库错误，获取公司成员失败")
		return
	}
	response.Success(c, gin.H{"userList": users}, "查询成功")
}

func ConfirmRejectInfo(c *gin.Context) {
	db := common.GetDB()
	userId := c.Params.ByName("userId")
	var request model.Company2Users
	if err := db.Model(&model.Company2Users{}).Where("user_id = ? and state = 2", userId).First(&request).Error; err != nil {
		response.Fail(c, nil, "该用户不在被拒绝列表中,无法撤回申请")
		return
	}
	if err := db.Model(&model.Company2Users{}).Where("user_id = ? and state = 2", userId).Delete(&request).Error; err != nil {
		response.Fail(c, nil, "数据库错误，未成功撤回申请")
		return
	}
	response.Success(c, nil, "加入公司的申请已被撤回，您可再次申请加入公司")
}

func GetCompanyStatisticsList(c *gin.Context) {
	var companies []model.Company
	db := common.GetDB()
	db.Model(&model.Company{}).Find(&companies)
	type result struct {
		model.Company
		TotalSendCount     int64 `json:"totalSendCount"`
		TotalRecvCount     int64 `json:"totalRecvCount"`
		TotalFinishedCount int64 `json:"totalFinishedCount"`
		TotalEngineer      int   `json:"totalEngineer"`
		TotalAdmin         int   `json:"totalAdmin"`
	}
	res := make([]result, len(companies))
	for i, v := range companies {
		totalSendCount, totalRecvCount, totalFinishedCount, totalEngineer, totalAdmin := GetCompanyStatisticsData(v.ID)
		res[i].TotalSendCount = totalSendCount
		res[i].TotalRecvCount = totalRecvCount
		res[i].TotalFinishedCount = totalFinishedCount
		res[i].TotalEngineer = totalEngineer
		res[i].TotalAdmin = totalAdmin
		v.CertificateUrl = ""
		res[i].Company = v
	}
	response.Success(c, gin.H{"companyList": res}, "查询成功")
}

func GetCompanyStatisticsData(companyId int) (int64, int64, int64, int, int) {

	db := common.GetDB()
	//总发包数
	var totalSendCount int64
	db.Model(&model.Task{}).Where("company_id = ?", companyId).Count(&totalSendCount)
	//发包中总接包数
	var totalRecvCount int64
	db.Model(&model.Task{}).Where("company_id = ? and state <> 3", companyId).Count(&totalRecvCount)

	//发包中总完成数
	var totalFinishedCount int64
	db.Model(&model.Task{}).Where("company_id = ? and task.state = 2", companyId).Count(&totalFinishedCount)
	// 公司中测试工程师的人数
	var totalEngineer int
	db.Raw("SELECT count(*) FROM company_users left join `user` on company_users.user_id = user.id "+
		"WHERE company_users.company_id = ? and company_users.state= 1 AND identify = 2", companyId).First(&totalEngineer)
	// 公司中测试管理员的人数
	var totalAdmin int
	db.Raw("SELECT count(*) FROM company_users left join `user` on company_users.user_id = user.id "+
		"WHERE company_users.company_id = ? and company_users.state= 1 AND identify = 1", companyId).First(&totalAdmin)

	return totalSendCount, totalRecvCount, totalFinishedCount, totalEngineer, totalAdmin

}

func GetCompanyStatistics(c *gin.Context) {
	companyId := c.Params.ByName("companyId")
	db := common.GetDB()
	var company model.Company
	if err := db.Model(&model.Company{}).Where("id = ?", companyId).First(&company).Error; err != nil {
		response.Fail(c, nil, "公司不存在")
		return
	}
	companyIntId, _ := strconv.Atoi(companyId)
	totalSendCount, totalRecvCount, totalFinishedCount, totalEngineer, totalAdmin := GetCompanyStatisticsData(companyIntId)
	response.Success(c, gin.H{
		"company":            company,
		"totalSendCount":     totalSendCount,
		"totalRecvCount":     totalRecvCount,
		"totalFinishedCount": totalFinishedCount,
		"totalEngineer":      totalEngineer,
		"totalAdmin":         totalAdmin,
	}, "查询成功")
}