package service

import (
	"context"
	"github.com/fonchain_enterprise/fonchain-approval/api/approval"
	"github.com/fonchain_enterprise/fonchain-approval/pkg/model"
	"github.com/fonchain_enterprise/fonchain-approval/pkg/serializer"
	"gorm.io/gorm"
)

type ApprovalProvider struct {
	approval.UnimplementedApprovalServer
}

func (a *ApprovalProvider) Create(ctx context.Context, in *approval.CreateRequest) (*approval.ApprovalResponse, error) {
	response := &approval.ApprovalResponse{}

	entity, err := model.StoreApproval(in)
	response.ID = entity.ID
	response.Success = true

	return response, err
}

func (a *ApprovalProvider) Update(ctx context.Context, in *approval.CreateRequest) (*approval.ApprovalResponse, error) {

	response := &approval.ApprovalResponse{}

	entity, err := model.UpdateApproval(in)

	response.ID = entity.ID
	response.Success = true

	return response, err

}

func (a *ApprovalProvider) Remove(ctx context.Context, in *approval.DetailRequest) (*approval.RemoveResponse, error) {

	response := &approval.RemoveResponse{}

	err := model.DB.Transaction(func(tx *gorm.DB) error {

		var err error
		var entity *model.Approval

		// 确定有数据则执行删除
		if err = model.DB.Where(&model.Approval{Domain: &in.Domain}).
			Find(&entity, in.ID).Error; err != nil {
			return err
		}

		//删除子关联数据
		if err = entity.DeleteContent(); err != nil {
			return err
		}

		if err = model.DB.Where(&model.Approval{Domain: &in.Domain}).
			Delete(&model.Approval{}, in.ID).Error; err != nil {
			return err
		}

		return nil

	})

	if err != nil {
		return nil, err
	}

	response.Success = true

	return response, nil

}

func (a *ApprovalProvider) Detail(ctx context.Context, in *approval.DetailRequest) (*approval.CreateRequest, error) {
	response := &approval.CreateRequest{}
	var err error
	var entity *model.Approval
	if err := model.DB.First(&entity, in.ID).Error; err != nil {
		return response, err
	}

	response = serializer.BuildApproval(entity)

	return response, err
}

func (a *ApprovalProvider) Information(ctx context.Context, in *approval.InformationRequest) (*approval.InformationResponse, error) {

	return model.ApprovalInfo(in)

}

func (a *ApprovalProvider) Viewed(ctx context.Context, in *approval.ViewedRequest) (*approval.ApprovalResponse, error) {

	response := &approval.ApprovalResponse{}
	var err error

	if err = model.Viewed(in); err != nil {
		return response, err
	}

	response.ID = in.ID
	response.Success = true

	return response, err

}

func (a *ApprovalProvider) List(ctx context.Context, in *approval.ApprovalListRequest) (*approval.ApprovalListResponse, error) {

	//获取人的 部门角色（1、管理组 2、超级管理 3、Leader角色）
	response := &approval.ApprovalListResponse{}

	var list []*model.Approval
	var count int64

	list, count = model.ApprovalList(in)

	response.Count = uint64(count)
	response.Data = serializer.BuildApprovals(list)
	return response, nil
}

// UpdateSetting 设置配置抄送者和审核者
func (a *ApprovalProvider) UpdateSetting(ctx context.Context, in *approval.SettingRequest) (*approval.SettingResponse, error) {

	var err error
	response := &approval.SettingResponse{}
	var setting model.DepartmentApprovalSetting
	copyUsers := model.FormatCopyUsers(in.CopyUsers)

	//首次
	if err := model.DB.Model(&model.DepartmentApprovalSetting{}).
		Where(&model.DepartmentApprovalSetting{Domain: in.Domain, DepartmentID: in.DepartmentID}).
		First(&setting).Error; err != nil {

		setting = model.DepartmentApprovalSetting{
			DepartmentID: in.DepartmentID,
			CopyUsers:    copyUsers,
			ApproverID:   in.ApproverID,
			ApproverName: in.ApproverName,
			Domain:       in.Domain,
		}
	} else {
		setting.DepartmentID = in.DepartmentID
		setting.CopyUsers = copyUsers
		setting.ApproverID = in.ApproverID
		setting.ApproverName = in.ApproverName
	}

	err = model.DB.Save(&setting).Error

	response.ID = setting.ID
	response.Success = true
	return response, err
}

func (a *ApprovalProvider) DetailSetting(ctx context.Context, in *approval.DetailSettingRequest) (*approval.SettingRequest, error) {

	response := &approval.SettingRequest{}
	var setting model.DepartmentApprovalSetting

	if err := model.DB.Model(&model.DepartmentApprovalSetting{}).
		Where(&model.DepartmentApprovalSetting{Domain: in.Domain, DepartmentID: in.DepartmentID}).
		First(&setting).Error; err != nil {
		response.Domain = in.Domain
	} else {
		response = serializer.BuildSetting(&setting)
	}

	return response, nil
}