package train

import (
	"context"
	projDao "dashoo.cn/micro/app/dao/train"
	model "dashoo.cn/micro/app/model/train"
	"dashoo.cn/micro/app/service"
	"dashoo.cn/opms_libary/myerrors"
	"database/sql"
	"github.com/gogf/gf/database/gdb"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/os/gtime"
)

type trainHeadService struct {
	*service.ContextService
	Dao       *projDao.TrainHeadOfficeDao
	FeedDao   *projDao.TrainHeadOfficeFeedbackDao
	DetailDao *projDao.TrainHeadOfficeFeedbackDetailDao
}

func NewtrainHeadService(ctx context.Context) (svc *trainHeadService, err error) {
	svc = new(trainHeadService)
	if svc.ContextService, err = svc.Init(ctx); err != nil {
		return nil, err
	}
	svc.Dao = projDao.NewTrainHeadOfficeDao(svc.Tenant)
	svc.FeedDao = projDao.NewTrainHeadOfficeFeedbackDao(svc.Tenant)
	svc.DetailDao = projDao.NewTrainHeadOfficeFeedbackDetailDao(svc.Tenant)

	return svc, nil
}

func (s *trainHeadService) GetList(req *model.SearchTrainHeadReq) (total int, list []*model.SearchTrainHeadRes, err error) {
	db := s.Dao.Ctx(s.Ctx)

	if req.TrainTitle != "" {
		db = db.WhereLike(s.Dao.C.TrainTitle, "%"+req.TrainTitle+"%")
	}
	//if req.TrainStartDate != nil {
	//	db = db.Where("train_date >=?", req.TrainStartDate)
	//}
	//if req.TrainEndDate != nil {
	//	db = db.Where("train_date <=?", req.TrainEndDate)
	//}

	total, err = db.Count()
	if err != nil {
		return 0, nil, err
	}

	err = db.OrderDesc(s.Dao.C.CreatedTime).Page(req.GetPage()).Scan(&list)
	//if err != nil && err != sql.ErrNoRows {
	if err != nil {

		return 0, nil, err
	}
	return total, list, nil
}

func (s *trainHeadService) GetEntityById(id int64) (detail *model.TrainHeadDetail, err error) {

	err = s.Dao.WherePri(id).Scan(&detail)

	if err == sql.ErrNoRows {
		return nil, myerrors.TipsError("工单不存在")
	}
	if err != nil {
		return nil, err
	}
	saleList := make([]*model.Sale, 0)
	err = s.FeedDao.Where(s.FeedDao.C.TrainId, id).Scan(&saleList)
	if err != nil {
		return nil, err
	}
	feedBackDetailList := make([]*model.FeedbackDetail, 0)
	err = s.DetailDao.Ctx(s.Ctx).Where(s.DetailDao.C.MainId, id).Scan(&feedBackDetailList)
	if err != nil {
		return nil, err
	}

	detail.SaleList = saleList
	detail.DistributorList = feedBackDetailList

	return detail, nil
}

func (s *trainHeadService) GetDetailById(id int64) (detail *model.TrainHeadDetailForFeedBack, err error) {

	err = s.Dao.WherePri(id).Scan(&detail)

	if err == sql.ErrNoRows {
		return nil, myerrors.TipsError("工单不存在")
	}
	if err != nil {
		return nil, err
	}
	disList := make([]*model.FeedbackDetail, 0)
	err = s.DetailDao.Ctx(s.Ctx).Where(s.DetailDao.C.MainId, id).Where(s.DetailDao.C.SaleId, s.GetCxtUserId()).Scan(&disList)
	if err != nil {
		return nil, err
	}

	detail.DistributorList = disList

	return detail, nil
}

func (s *trainHeadService) Create(req *model.CreateTrainHead) (err error) {

	ent := model.TrainHeadOffice{
		Id:                     0,
		TrainTitle:             req.TrainTitle,
		TrainDate:              req.TrainDate,
		TrainConcreteStartTime: req.TrainConcreteStartTime,
		TrainConcreteEndTime:   req.TrainConcreteEndTime,
		CreatedBy:              s.GetCxtUserId(),
		CreatedName:            s.GetCxtUserName(),
		CreatedTime:            gtime.Now(),
	}
	//service.SetCreatedInfo(ent, s.GetCxtUserId(), s.GetCxtUserName())

	e := s.Dao.Transaction(s.Ctx, func(ctx context.Context, tx *gdb.TX) error {
		id, err := s.Dao.TX(tx).InsertAndGetId(ent)
		if err != nil {
			return myerrors.TipsError("提取方案创建失败，请联系管理员")
		}
		createSaleList := make([]*model.TrainHeadOfficeFeedback, 0)
		DetailList := make([]*model.TrainHeadOfficeFeedbackDetail, 0)
		for _, sale := range req.SaleList {
			createSale := model.TrainHeadOfficeFeedback{
				TrainId:     int(id),
				SaleId:      sale.SaleId,
				SaleName:    sale.SaleName,
				CreatedBy:   s.GetCxtUserId(),
				CreatedName: s.GetCxtUserName(),
				CreatedTime: gtime.Now(),
			}
			createSaleList = append(createSaleList, &createSale)
		}

		for _, distributor := range req.DistributorList {
			detail := model.TrainHeadOfficeFeedbackDetail{
				MainId:          int(id),
				SaleId:          distributor.SaleId,
				SaleName:        distributor.SaleName,
				DistributorId:   distributor.DistributorId,
				DistributorName: distributor.DistributorName,
				CreatedBy:       s.GetCxtUserId(),
				CreatedName:     s.GetCxtUserName(),
				CreatedTime:     gtime.Now(),
			}
			DetailList = append(DetailList, &detail)

		}
		_, err = s.FeedDao.Ctx(s.Ctx).InsertAndGetId(createSaleList)
		if err != nil {
			return myerrors.TipsError("提取方案创建失败，请联系管理员")
		}

		_, err = s.DetailDao.Ctx(s.Ctx).InsertAndGetId(DetailList)
		if err != nil {
			return myerrors.TipsError("提取方案创建失败，请联系管理员")
		}
		return nil
	})

	return e
}

// func (s *trainHeadService) UpdateById(req *model.UpdateTrainHead) error {
//
//		ent := model.TrainHeadOffice{}
//		err := s.Dao.WherePri(req.Id).Scan(&ent)
//		if err == sql.ErrNoRows {
//			return myerrors.TipsError("该培训工单不存在")
//		}
//		if err != nil {
//			return err
//		}
//
//		updateMap := g.Map{
//			s.Dao.C.TrainTitle:             req.TrainTitle,
//			s.Dao.C.TrainDate:              req.TrainDate,
//			s.Dao.C.TrainConcreteStartTime: req.TrainConcreteStartTime,
//			s.Dao.C.TrainConcreteEndTime:   req.TrainConcreteEndTime,
//			s.Dao.C.UpdatedBy:              s.GetCxtUserId(),
//			s.Dao.C.UpdatedName:            s.GetCxtUserName(),
//			s.Dao.C.UpdatedTime:            gtime.Now(),
//		}
//		e := s.Dao.Transaction(s.Ctx, func(ctx context.Context, tx *gdb.TX) error {
//			_, err = s.Dao.Ctx(ctx).TX(tx).Data(updateMap).WherePri(req.Id).FieldsEx(service.UpdateFieldEx...).Update()
//			if err != nil {
//				return myerrors.TipsError("修改培训工单失败")
//			}
//			for _, feedBack := range req.FeedbackList {
//				switch feedBack.Operate {
//				case "10":
//					TrainHeadSetting := model.TrainHeadOfficeFeedback{
//						TrainId:     int(req.Id),
//						SaleId:      feedBack.Sale.SaleId,
//						SaleName:    feedBack.Sale.SaleName,
//						CreatedBy:   s.GetCxtUserId(),
//						CreatedName: s.GetCxtUserName(),
//						CreatedTime: gtime.Now(),
//					}
//					//service.SetCreatedInfo(TrainHeadSetting, s.GetCxtUserId(), s.GetCxtUserName())
//					DetailList := make([]*model.TrainHeadOfficeFeedbackDetail, 0)
//					//CreateSetting = append(CreateSetting, &TrainHeadSetting)
//					settingId, err := s.FeedDao.TX(tx).InsertAndGetId(TrainHeadSetting)
//					//CreateSetting := make([]*model.TrainHeadOfficeFeedback, 0)
//					for _, Dis := range feedBack.DistributorList {
//						detail := model.TrainHeadOfficeFeedbackDetail{
//							MainId:          int(settingId),
//							DistributorId:   Dis.DistributorId,
//							DistributorName: Dis.DistributorName,
//							CreatedBy:       s.GetCxtUserId(),
//							CreatedName:     s.GetCxtUserName(),
//							CreatedTime:     gtime.Now(),
//						}
//						//service.SetCreatedInfo(detail, s.GetCxtUserId(), s.GetCxtUserName())
//						DetailList = append(DetailList, &detail)
//
//					}
//					_, err = s.DetailDao.TX(tx).Insert(DetailList)
//					if err != nil {
//						return myerrors.TipsError("培训工单修改失败")
//					}
//
//				case "20":
//
//					_, err = s.FeedDao.Ctx(ctx).TX(tx).Data(g.Map{
//						s.FeedDao.C.SaleId:   feedBack.Sale.SaleId,
//						s.FeedDao.C.SaleName: feedBack.Sale.SaleId,
//						s.Dao.C.UpdatedBy:    s.GetCxtUserId(),
//						s.Dao.C.UpdatedName:  s.GetCxtUserName(),
//						s.Dao.C.UpdatedTime:  gtime.Now(),
//					}).WherePri(feedBack.Id).FieldsEx(service.UpdateFieldEx...).Update()
//					_, err = s.DetailDao.TX(tx).Where(s.DetailDao.C.MainId, feedBack.Id).Delete()
//					if err != nil {
//						return myerrors.TipsError("培训工单修改失败")
//					}
//					DetailList := make([]*model.TrainHeadOfficeFeedbackDetail, 0)
//					for _, Dis := range feedBack.DistributorList {
//						detail := model.TrainHeadOfficeFeedbackDetail{
//							MainId:          int(feedBack.Id),
//							DistributorId:   Dis.DistributorId,
//							DistributorName: Dis.DistributorName,
//							CreatedBy:       s.GetCxtUserId(),
//							CreatedName:     s.GetCxtUserName(),
//							CreatedTime:     gtime.Now(),
//						}
//						DetailList = append(DetailList, &detail)
//
//					}
//					_, err = s.DetailDao.TX(tx).Insert(DetailList)
//
//					if err != nil {
//						return myerrors.TipsError("培训工单修改失败")
//					}
//
//				case "30":
//					_, err := s.FeedDao.Ctx(ctx).TX(tx).WherePri(feedBack.Id).Delete()
//					if err != nil {
//						return myerrors.TipsError("培训工单修改失败")
//					}
//				}
//
//			}
//			return nil
//		})
//
//		return e
//	}
func (s *trainHeadService) FeedBackTrain(req *model.FeedBackTrainReq) error {
	for _, feedback := range req.FeedBackTrainList {
		_, err := s.DetailDao.Data(g.Map{
			s.DetailDao.C.TrainingPersNum:     feedback.TrainingPersNum,
			s.DetailDao.C.DistributorFeedback: feedback.DistributorFeedback,
			s.Dao.C.UpdatedBy:                 s.GetCxtUserId(),
			s.Dao.C.UpdatedName:               s.GetCxtUserName(),
			s.Dao.C.UpdatedTime:               gtime.Now(),
		}).FieldsEx(service.UpdateFieldEx...).WherePri(feedback.Id).Update()
		if err != nil {
			return myerrors.TipsError("培训工单反馈提交失败，请稍后重试")
		}
	}

	return nil
}

func (s *trainHeadService) DeleteByIds(ids []int64) error {
	if len(ids) == 0 {
		return nil
	}
	e := s.Dao.Transaction(s.Ctx, func(ctx context.Context, tx *gdb.TX) error {
		_, err := s.Dao.Ctx(ctx).WhereIn(s.Dao.C.Id, ids).Delete()
		if err != nil {
			return myerrors.TipsError("培训工单删除失败，请稍后重试")
		}
		_, err = s.FeedDao.Ctx(ctx).TX(tx).WhereIn(s.FeedDao.C.TrainId, ids).Delete()
		if err != nil {
			return myerrors.TipsError("培训工单删除失败，请稍后重试")
		}

		return nil
	})

	return e
}