package bus_service

import (
	"errors"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/go-admin-team/go-admin-core/sdk/pkg/jwtauth/user"
	"github.com/go-admin-team/go-admin-core/sdk/service"
	"go-admin/app/admin/models/bus_models"
	aliyun "go-admin/tools/ali"
	"gorm.io/gorm"
	"math/rand"
	"strings"
	"time"
)

type ContractService struct {
	service.Service
}

// CreateContract 新建合同
func (s *ContractService) CreateContract(c *gin.Context, req bus_models.CreateContractReq) (bus_models.CreateContractResp, error) {
	var resp bus_models.CreateContractResp
	contract := bus_models.BusContract{
		CooperativeNumber: req.CooperativeNumber,
		CooperativeName:   req.CooperativeName,
		Files:             req.Files,
		Status:            1,
		SignatoryAccount:  user.GetUserName(c),
		Remark:            req.Remark,
	}

	contractNumber, err := GenerateContractNumber(s.Orm, "CN")
	if err != nil {
		fmt.Println("生成合同编号失败:", err)
	} else {
		fmt.Println("生成的合同编号为:", contractNumber)
	}
	contract.ContractNumber = contractNumber

	if err := s.Orm.Create(&contract).Error; err != nil {
		return resp, errors.New("创建合同失败")
	}

	resp.ContractNumber = contract.ContractNumber
	return resp, nil
}

// EditContract 编辑合同信息
func (s *ContractService) EditContract(req bus_models.EditContractReq) error {
	// 查找合同是否存在
	var contract bus_models.BusContract
	if err := s.Orm.Where("contract_number = ?", req.ContractNumber).First(&contract).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return errors.New("合同不存在")
		}
		return err
	}

	// 更新字段
	updateData := map[string]interface{}{}
	if req.CooperativeNumber != "" {
		updateData["cooperative_number"] = req.CooperativeNumber
	}
	if req.CooperativeName != "" {
		updateData["cooperative_name"] = req.CooperativeName
	}
	if req.SignatoryAccount != "" {
		updateData["signatory_account"] = req.SignatoryAccount
	}
	if req.Remark != "" {
		updateData["remark"] = req.Remark
	}

	// 执行更新
	if len(updateData) > 0 {
		result := s.Orm.Model(&bus_models.BusContract{}).
			Where("contract_number = ?", req.ContractNumber).
			Updates(updateData)

		if result.Error != nil {
			return result.Error
		}
		if result.RowsAffected == 0 {
			return errors.New("合同未更新或不存在")
		}
	}

	return nil
}

// ListContracts 获取合同列表
func (s *ContractService) ListContracts(req bus_models.ListContractReq) (bus_models.ListContractResp, error) {
	page := req.Page - 1
	if page < 0 {
		page = 0
	}
	if req.PageSize == 0 {
		req.PageSize = 10
	}

	var resp bus_models.ListContractResp
	var contracts []bus_models.BusContract
	var total int64

	query := s.Orm.Model(&bus_models.BusContract{})

	if req.ContractNumber != "" {
		query = query.Where("contract_number = ?", req.ContractNumber)
	}
	if req.CooperativeNumber != "" {
		query = query.Where("cooperative_number = ?", req.CooperativeNumber)
	}
	if req.Status > 0 {
		query = query.Where("status = ?", req.Status)
	}

	// 计算总数
	if err := query.Count(&total).Error; err != nil {
		return resp, err
	}

	// 分页查询
	if err := query.Offset(page * req.PageSize).Limit(req.PageSize).Find(&contracts).Error; err != nil {
		return resp, err
	}

	resp.List = contracts
	resp.Total = len(contracts)
	resp.Page = page + 1
	resp.PageSize = req.PageSize

	return resp, nil
}

// GetContractDetail 获取合同详情
func (s *ContractService) GetContractDetail(req bus_models.ContractDetailReq) (*bus_models.BusContract, error) {
	var contract bus_models.BusContract
	if err := s.Orm.Where("contract_number = ?", req.ContractNumber).First(&contract).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, errors.New("合同不存在")
		}
		return nil, err
	}
	return &contract, nil
}

// UpdateContractRemark 编辑合同备注
func (s *ContractService) UpdateContractRemark(req bus_models.EditContractRemarkReq) error {
	result := s.Orm.Model(&bus_models.BusContract{}).
		Where("contract_number = ?", req.ContractNumber).
		Update("remark", req.Remark)

	if result.Error != nil {
		return result.Error
	}
	if result.RowsAffected == 0 {
		return errors.New("合同不存在")
	}
	return nil
}

// InvalidateContract 作废合同
func (s *ContractService) InvalidateContract(req bus_models.InvalidContractReq) error {
	result := s.Orm.Model(&bus_models.BusContract{}).
		Where("contract_number = ?", req.ContractNumber).
		Update("status", 2)

	if result.Error != nil {
		return result.Error
	}
	if result.RowsAffected == 0 {
		return errors.New("合同不存在")
	}
	return nil
}

// RemoveContract 删除合同
func (s *ContractService) RemoveContract(req bus_models.DeleteContractReq) error {
	// 首先检查合同状态是否是作废（status = 2）
	var contract bus_models.BusContract
	err := s.Orm.Where("contract_number = ?", req.ContractNumber).First(&contract).Error
	if err != nil {
		return err // 如果查询失败，返回错误
	}

	// 如果合同的状态是作废（status = 2），则不允许删除
	if contract.Status == 1 {
		return errors.New("合同未作废，不能删除")
	}

	result := s.Orm.Where("contract_number = ?", req.ContractNumber).Delete(&bus_models.BusContract{})

	if result.Error != nil {
		return result.Error // 返回删除操作中的错误
	}

	if result.RowsAffected == 0 {
		return errors.New("合同不存在") // 如果没有找到任何符合条件的合同
	}

	return nil // 删除成功
}

// GetContractDownloadLink 获取合同的下载链接
func (s *ContractService) GetContractDownloadLink(req bus_models.GetContractDownloadLinkReq) (
	bus_models.GetContractDownloadLinkResp, error) {
	var resp bus_models.GetContractDownloadLinkResp

	// 查找合同是否存在
	var contract bus_models.BusContract
	if err := s.Orm.Where("contract_number = ?", req.ContractNumber).First(&contract).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return resp, errors.New("合同不存在")
		}
		return resp, err
	}

	// 解析 Files 字段，假设它是一个以分号分隔的文件名列表
	files := strings.Split(contract.Files, ";")
	if len(files) == 0 {
		return resp, errors.New("合同文件不存在")
	}

	// 循环获取每个文件的预签名 URL
	var downloadLinks []string
	for _, file := range files {
		// 调用 Aliyun OSS 的 GeneratePresignedURL 方法生成预签名 URL
		downloadURL, err := aliyun.GeneratePresignedURL(file)
		if err != nil {
			return resp, err
		}
		downloadLinks = append(downloadLinks, downloadURL)
	}

	// 将所有的 URL 通过分号连接起来
	resp.DownloadURL = downloadLinks

	// 返回生成的下载链接
	return resp, nil
}

// GenerateContractNumber 生成唯一的合同编号，格式为：合同简写+日期+8位随机数
func GenerateContractNumber(db *gorm.DB, contractPrefix string) (string, error) {
	// 获取当前日期（年月日）
	dateStr := time.Now().Format("20060102") // 格式为：YYYYMMDD

	// 生成一个8位随机数
	rand.Seed(time.Now().UnixNano())    // 设置随机数种子
	randomNum := rand.Int63n(100000000) // 生成一个0到99999999之间的随机数

	// 将随机数转为固定长度的字符串，确保8位
	randomNumStr := fmt.Sprintf("%08d", randomNum) // 确保为8位，不足补零

	// 拼接合同简写、日期和随机数
	contractNumber := fmt.Sprintf("%s%s%s", contractPrefix, dateStr, randomNumStr)

	// 检查生成的合同编号是否已存在
	var count int64
	err := db.Model(&bus_models.BusContract{}).Where("contract_number = ?", contractNumber).Count(&count).Error
	if err != nil {
		return "", err
	}

	// 如果已存在，重新生成
	if count > 0 {
		return GenerateContractNumber(db, contractPrefix) // 递归重新生成
	}

	return contractNumber, nil
}