package base

import (
	"context"
	"dashoo.cn/opms_libary/myerrors"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/util/gconv"

	"dashoo.cn/micro/app/dao/base"
	"dashoo.cn/micro/app/dao/cust"
	model "dashoo.cn/micro/app/model/base"
	"dashoo.cn/micro/app/service"
)

type salesRegionDetailService struct {
	*service.ContextService
	Dao         *base.BaseSalesRegionDetailDao
	District    *base.BaseDistrictDao
	CustomerDao *cust.CustCustomerDao
}

func NewSalesRegionDetailService(ctx context.Context) (svc *salesRegionDetailService, err error) {
	svc = new(salesRegionDetailService)
	if svc.ContextService, err = svc.Init(ctx); err != nil {
		return nil, err
	}
	svc.Dao = base.NewBaseSalesRegionDetailDao(svc.Tenant)
	svc.District = base.NewBaseDistrictDao(svc.Tenant)
	svc.CustomerDao = cust.NewCustCustomerDao(svc.Tenant)
	return svc, nil
}

// GetList 销售区域列表
func (s *salesRegionDetailService) GetList(req *model.SecBaseRegionDetailReq) (total int, RegionList []*model.BaseRegionDetailRep, err error) {
	Model := s.Dao.Where(s.Dao.C.RegionId, req.RegionId)
	total, err = Model.Count()
	if err != nil {
		err = myerrors.DbError("获取总行数失败。")
		return
	}
	err = Model.Page(req.GetPage()).Order("id asc").Scan(&RegionList)
	if err != nil {
		return
	}
	var districtList []int
	for _, v := range RegionList {
		districtList = append(districtList, v.CustCityId)
	}
	//CustModel := p.CustomerDao.M
	CustModel := s.CustomerDao.DataScope(s.Ctx, "sales_id").M.Fields("count(*) as count,cust_city_id").Where("cust_city_id in (?)", districtList)
	if req.CustName != "" {
		CustModel = CustModel.Where(s.CustomerDao.C.CustName+" like ?", "%"+req.CustName+"%")
	}
	if req.CustCode != "" {
		CustModel = CustModel.Where(s.CustomerDao.C.CustCode+" like ?", "%"+req.CustCode+"%")
	}
	if req.CustIndustry != "" {
		CustModel = CustModel.Where(s.CustomerDao.C.CustIndustry+" like ?", "%"+req.CustIndustry+"%")
	}

	custDist, _ := CustModel.Group("cust_city_id").All()

	for _, v := range RegionList {
		for _, v3 := range custDist {
			if v.CustCityId == gconv.Int(v3["cust_city_id"]) {
				v.Count = gconv.Int(v3["count"])
			}
		}
	}
	return
}

// 创建区域
func (s *salesRegionDetailService) Create(req *model.AddBaseRegionDetailReq) (err error) {
	detailData := new(model.BaseSalesRegionDetail)
	if err = gconv.Struct(req, detailData); err != nil {
		return
	}
	service.SetCreatedInfo(detailData, s.GetCxtUserId(), s.GetCxtUserName())
	_, err = s.Dao.Insert(detailData)
	if err != nil {
		g.Log().Error(err)
		return err
	}
	return nil

}

// UpdateById   修改
func (s *salesRegionDetailService) UpdateById(req *model.UpdateBaseRegionDetailReq) (err error) {
	count, err := s.Dao.FindCount(req.Id)
	if err != nil {
		g.Log().Error(err)
		return
	}
	if count == 0 {
		err = myerrors.TipsError("数据不存在")
		return
	}

	productData := new(model.BaseSalesRegionDetail)
	if err = gconv.Struct(req, productData); err != nil {
		return
	}
	service.SetUpdatedInfo(productData, s.GetCxtUserId(), s.GetCxtUserName())
	_, err = s.Dao.FieldsEx(service.UpdateFieldEx...).WherePri(base.BaseSalesRegionDetail.C.Id, req.Id).Update(productData)

	if err != nil {
		g.Log().Error(err)
		return
	}
	return
}

// DeleteByIds 删除
func (s *salesRegionDetailService) DeleteByIds(ids []int64) (err error) {
	_, err = s.Dao.WhereIn(s.Dao.C.Id, ids).Delete()
	return
}