package service

import (
	"joybuywork/internal/app"
	"joybuywork/internal/consts/ckey"
	"joybuywork/internal/plugins/encrypt"
	"joybuywork/internal/repository/cache"
	"joybuywork/internal/repository/dbcheck"
	"joybuywork/internal/repository/finder"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/repository/withdefault"
	"joybuywork/internal/service/containers"
	"joybuywork/internal/service/provider"
	"joybuywork/internal/utils/logic"
	pb "joybuywork/proto/go_proto/w_project"
	"joybuywork/proto/go_proto/workerr"
	"time"
)

type WProject struct {
	Service
}

// Select 选择列表
func (s *WProject) Select(req *pb.SelectReq, res *pb.SelectRes) (err error) {
	defer s.checkErr()

	m := s.GetDao().Project

	var list []*model.Project
	if req.ShowUser {
		relateM := s.GetDao().UserProjectRelate
		var projectIds []int64

		err = relateM.WithContext(s.ctx).Where(relateM.UserID.Eq(req.GetUserId()), relateM.IsDel.Eq(mtype.No)).Pluck(relateM.ProjectID, &projectIds)
		if err != nil {
			return s.BE().MysqlError(err)
		}

		if len(projectIds) > 0 {
			list, err = m.WithContext(s.ctx).Where(m.ID.In(projectIds...), m.IsDel.Eq(mtype.No)).Find()
			if err != nil {
				return s.BE().MysqlError(err)
			}
		}

	} else {
		list, err = m.WithContext(s.ctx).Where(m.CompanyID.Eq(req.GetCompanyId()), m.IsDel.Eq(mtype.No)).Find()
		if err != nil {
			return s.BE().MysqlError(err)
		}
	}

	*res = pb.SelectRes{
		List: make([]*pb.SelectRes_One, 0, len(list)),
	}

	for _, v := range list {
		res.List = append(res.List, &pb.SelectRes_One{
			Id:      v.ID,
			HashId:  v.HashID,
			Title:   v.Title,
			Scene:   int32(v.Scene),
			LogoUrl: v.LogoURL,
			IsTest:  int32(v.IsTest),
		})
	}

	return
}

// List 用户列表
func (s *WProject) List(req *pb.ListReq, res *pb.ListRes) (err error) {
	defer s.checkErr()
	*res = pb.ListRes{}

	container := new(containers.ProjectList)
	{
		container.Init(s.ctx)
		container.Req = req
		container.Res = res
	}

	return container.Run()
}

// Store 创建项目
func (s *WProject) Store(req *pb.StoreReq, res *pb.StoreRes) (err error) {
	defer s.checkErr()
	*res = pb.StoreRes{}
	container := new(containers.ProjectStore)
	{
		container.Init(s.ctx, logic.WithTran())
		container.Req = req
		container.Res = res
	}

	return container.Run()
}

// Update 更新项目
func (s *WProject) Update(req *pb.UpdateReq, res *pb.UpdateRes) (err error) {
	defer s.checkErr()
	*res = pb.UpdateRes{}

	container := new(containers.ProjectUpdate)
	{
		container.Init(s.ctx, logic.WithTran())
		container.Req = req
		container.Res = res
	}

	return container.Run()
}

// Destroy 删除项目
func (s *WProject) Destroy(req *pb.DestroyReq, res *pb.DestroyRes) (err error) {
	defer s.checkErr()
	*res = pb.DestroyRes{}

	project, err := finder.Project(s.ctx, req.GetId(), req.GetHashId())
	if err != nil {
		return s.BE().CacheError(err)
	}

	if project == nil || project.IsDel == mtype.Yes {
		return
	}

	m := s.GetDao().Project

	_, err = m.WithContext(s.ctx).Where(m.ID.Eq(project.ID)).UpdateSimple(m.IsDel.Value(mtype.Yes))
	if err != nil {
		return s.BE().MysqlError(err)
	}

	err = cache.NewProject(s.ctx).Clear(project)
	if err != nil {
		return s.BE().CacheError(err)
	}

	return
}

// Cert 项目认证
func (s *WProject) Cert(req *pb.CertReq, res *pb.CertRes) (err error) {
	defer s.checkErr()
	project, err := finder.Project(s.ctx, req.GetId(), req.GetHashId())
	if err != nil {
		return s.BE().CacheError(err)
	}

	if project == nil || project.IsDel == mtype.Yes {
		return workerr.NotFound("not found project")
	}

	// 找没有删除的project 密钥，并且七天内删除的密钥
	secretM := s.GetDao().ProjectSecret
	secrets, err := secretM.WithContext(s.ctx).
		Where(
			secretM.ProjectID.Eq(project.ID),
		).Where(
		secretM.WithContext(s.ctx).
			Where(secretM.IsDel.Eq(mtype.No)).
			Or(
				secretM.WithContext(s.ctx).Where(
					secretM.UpdatedAt.Gte(time.Now().AddDate(0, 0, -7).Unix()),
					secretM.IsDel.Eq(mtype.Yes),
				),
			)).
		Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	*res = pb.CertRes{
		Id:          project.ID,
		HashId:      project.HashID,
		Title:       project.Title,
		EncryptStr:  project.EncryptStr,
		Scene:       int32(project.Scene),
		CertSecrets: make([]*pb.CertRes_CertSecret, 0, len(secrets)),
	}

	for _, v := range secrets {
		one := &pb.CertRes_CertSecret{
			Secret:    v.AccessSecret,
			ExpiredAt: 0,
		}

		if v.IsDel == mtype.Yes {
			one.ExpiredAt = v.UpdatedAt - time.Now().AddDate(0, 0, -7).Unix()
		}

		res.CertSecrets = append(res.CertSecrets, one)
	}

	return
}

// ProjectSecret 项目私钥
func (s *WProject) ProjectSecret(req *pb.ProjectSecretReq, res *pb.ProjectSecretRes) (err error) {
	defer s.checkErr()

	project, err := finder.Project(s.ctx, req.GetId(), req.GetHashId())
	if err != nil {
		return s.BE().CacheError(err)
	}

	if project == nil || project.IsDel == mtype.Yes {
		return workerr.NotFound("not found project")
	}

	m := s.GetDao().ProjectSecret
	secret, err := m.WithContext(s.ctx).Where(m.ProjectID.Eq(project.ID), m.IsDel.Eq(mtype.No)).Take()
	if err = dbcheck.DbError(err); err != nil {
		return s.BE().MysqlError(err)
	}

	if secret == nil {
		return nil
	}

	*res = pb.ProjectSecretRes{
		Secret: secret.AccessSecret,
	}

	return
}

// ChangeSecret 修改密钥
func (s *WProject) ChangeSecret(req *pb.ChangeSecretReq, res *pb.ChangeSecretRes) (err error) {
	defer s.checkErr()
	project, err := finder.Project(s.ctx, req.GetId(), req.GetHashId())
	if err != nil {
		return s.BE().CacheError(err)
	}

	if project == nil || project.IsDel == mtype.Yes {
		return workerr.NotFound("project not found")
	}

	//保证只有一个账号被创建
	onceKey := ckey.ProjectSecretOnce(project.ID)
	lc := app.NewRedisLock(s.ctx, onceKey)
	defer lc.Release()
	if !lc.SoftLock() {
		return workerr.OnceLockError
	}

	m := s.GetDao().ProjectSecret
	old, err := m.WithContext(s.ctx).Where(m.ProjectID.Eq(project.ID), m.IsDel.Eq(mtype.No)).Take()
	if err = dbcheck.DbError(err); err != nil {
		return s.BE().MysqlError(err)
	}

	userM := s.GetDao().User
	user, err := userM.WithContext(s.ctx).Where(userM.Username.Eq(req.GetUsername()), userM.IsDel.Eq(mtype.No)).Take()
	if err = dbcheck.DbError(err); err != nil {
		return s.BE().MysqlError(err)
	}

	if user == nil || user.IsAdmin == mtype.No {
		return workerr.ChangAuthError
	}

	verify, err := encrypt.CheckUserPasswd(req.GetPasswd(), user.Passwd)
	if err != nil || !verify {
		return workerr.ChangAuthError
	}

	if old != nil {
		_, err = m.WithContext(s.ctx).Where(m.ID.Eq(old.ID)).UpdateSimple(m.IsDel.Value(mtype.Yes))
		if err != nil {
			return s.BE().MysqlError(err)
		}
	}

	secret := withdefault.ProjectSecret(&model.ProjectSecret{
		CreatorID:    req.GetId(),
		ProjectID:    project.ID,
		AccessSecret: encrypt.ProjectSecret(project.ID),
	})

	err = m.WithContext(s.ctx).Create(secret)
	if err != nil {
		return s.BE().MysqlError(err)
	}

	*res = pb.ChangeSecretRes{
		Secret: secret.AccessSecret,
	}
	return
}

// Show 项目详情
func (s *WProject) Show(req *pb.ShowReq, res *pb.ShowRes) (err error) {
	defer s.checkErr()

	project, err := finder.Project(s.ctx, req.GetId(), req.GetHashId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if project == nil || project.IsDel == mtype.Yes {
		return workerr.NotFound("project not found")
	}

	*res = pb.ShowRes{
		Id:              project.ID,
		HashId:          project.HashID,
		Title:           project.Title,
		Domain:          project.Domain,
		CompanyId:       project.CompanyID,
		NotifyToken:     project.NotifyToken,
		EncryptStr:      project.EncryptStr,
		Scene:           int32(project.Scene),
		ThirdSecret:     project.ThirdSecret,
		FissionCertType: int32(project.FissionCertType),
		ThirdUrl:        project.ThirdURL,
		ThirdReboostUrl: project.ThirdReboostURL,
	}
	return
}

// DomainList 获取项目域名绑定的项目
func (s *WProject) DomainList(req *pb.DomainListReq, res *pb.DomainListRes) (err error) {
	defer s.checkErr()

	m := s.GetDao().Project
	list, err := m.WithContext(s.ctx).Where(m.Domain.Eq(req.GetDomain())).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	*res = pb.DomainListRes{
		List: make([]*pb.DomainListRes_One, 0, len(list)),
	}

	for _, v := range list {
		res.List = append(res.List, &pb.DomainListRes_One{
			Id:          v.ID,
			HashId:      v.HashID,
			CompanyId:   v.CompanyID,
			Title:       v.Title,
			Domain:      v.Domain,
			CreatedTime: v.CreatedAt,
		})
	}

	return
}

// ChangeOplatform 修改开放平台
func (s *WProject) ChangeOplatform(req *pb.ChangeOplatformReq, res *pb.ChangeOplatformRes) (err error) {
	defer s.checkErr()
	project, err := finder.Project(s.ctx, req.GetId(), req.GetHashId())
	if err != nil {
		return s.BE().CacheError(err)
	}

	if project == nil || project.IsDel == mtype.Yes {
		return workerr.NotFound("project not found")
	}
	p := s.GetDao().Project
	_, err = p.WithContext(s.ctx).Where(p.HashID.Eq(req.GetHashId())).UpdateSimple(p.ThirdURL.Value(req.GetThirdUrl()))
	if err != nil {
		return s.BE().MysqlError(err)
	}
	// 清理缓存
	cache.NewProject(s.ctx).Clear(project)

	*res = pb.ChangeOplatformRes{}
	return
}

// SaveAdsConfig 保存广告修改
func (s *WProject) SaveAdsConfig(req *pb.SaveAdsConfigReq, res *pb.SaveAdsConfigRes) (err error) {
	defer s.checkErr()
	*res = pb.SaveAdsConfigRes{}
	container := new(containers.ProjectSaveAdsConfig)
	{
		container.Init(s.ctx, logic.WithTran(), logic.WithOnce(ckey.ProjectAdsOnce(req.GetProjectHashId())), logic.WithOl())
		container.Req = req
		container.Res = res
	}

	return container.Run()
}

// AdsConfig 获取广告配置
func (s *WProject) AdsConfig(req *pb.AdsConfigReq, res *pb.AdsConfigRes) (err error) {
	defer s.checkErr()

	project, err := s.ProjectErrNil(req.GetProjectHashId())
	if err != nil {
		return
	}

	ads, err := cache.NewProjectAd(s.ctx).FindByProjectId(project.ID)
	if err != nil {
		err = s.BE().CacheError(err)
	}

	if ads == nil {
		return
	}

	*res = pb.AdsConfigRes{
		OpenAd:      int32(ads.OpenAd),
		CampaignAd:  int32(ads.CampaignAd),
		AdCustomUrl: int32(ads.AdCustomURL),
	}
	return
}

// ChangeRebootUrl 修改开放平台的活动回调地址
func (s *WProject) ChangeRebootUrl(req *pb.ChangeRebootUrlReq, res *pb.ChangeRebootUrlRes) (err error) {
	defer s.checkErr()
	project, err := finder.Project(s.ctx, req.GetId(), req.GetHashId())
	if err != nil {
		return s.BE().CacheError(err)
	}

	if project == nil || project.IsDel == mtype.Yes {
		return workerr.NotFound("project not found")
	}
	p := s.GetDao().Project
	_, err = p.WithContext(s.ctx).Where(p.ID.Eq(project.ID)).UpdateSimple(p.ThirdReboostURL.Value(req.GetThirdReboostUrl()))
	if err != nil {
		return s.BE().MysqlError(err)
	}
	// 清理缓存
	cache.NewProject(s.ctx).Clear(project)
	*res = pb.ChangeRebootUrlRes{}
	return
}

// FissionConfig 获取广告配置
func (s *WProject) FissionConfig(req *pb.FissionConfigReq, res *pb.FissionConfigRes) (err error) {
	defer s.checkErr()
	project, err := finder.Project(s.ctx, req.GetProjectHashId())
	if err != nil {
		return s.BE().CacheError(err)
	}

	if project == nil {
		return
	}

	conf, err := provider.NewFissionConfig(s.ctx, project)
	if err != nil {
		return
	}

	*res = pb.FissionConfigRes{
		PushVisit:        int32(conf.Config().PushVisit),
		PushCampaignTask: int32(conf.Config().PushCampaignTask),
	}
	return
}

// SetPushVisit 设置活动访问推送开关
func (s *WProject) SetPushVisit(req *pb.SetPushVisitReq, res *pb.SetPushVisitRes) (err error) {
	defer s.checkErr()
	project, err := finder.Project(s.ctx, req.GetProjectHashId())
	if err != nil {
		return s.BE().CacheError(err)
	}

	conf, err := provider.NewFissionConfig(s.ctx, project)
	if err != nil {
		return
	}

	err = conf.SetPushVisit(req.GetPushVisit())
	if err != nil {
		return
	}

	*res = pb.SetPushVisitRes{}
	return
}

// SetPushCampaignTask 设置活动任务完成推送开关
func (s *WProject) SetPushCampaignTask(req *pb.SetPushCampaignTaskReq, res *pb.SetPushCampaignTaskRes) (err error) {
	defer s.checkErr()
	project, err := finder.Project(s.ctx, req.GetProjectHashId())
	if err != nil {
		return s.BE().CacheError(err)
	}

	conf, err := provider.NewFissionConfig(s.ctx, project)
	if err != nil {
		return
	}

	err = conf.SetPushCampaignTask(req.GetPushCampaignTask())
	if err != nil {
		return
	}

	*res = pb.SetPushCampaignTaskRes{}
	return
}