package mongo

import (
	"context"
	"finclip-app-manager/domain/entity"
	"finclip-app-manager/domain/entity/proto/apiproto"
	"finclip-app-manager/domain/repository"
	"strings"
	"time"

	mgo "gitlab.finogeeks.club/finclip-backend-v2/finclip-mgo"
	"gitlab.finogeeks.club/finclip-backend-v2/finclip-mgo/bson"
)

var _ repository.IBindingRepo = new(BindingByMongoRepo)

type BindingByMongoRepo struct {
}

func NewBindingByMongoRepo() *BindingByMongoRepo {
	return &BindingByMongoRepo{}
}

// 这张表暂时废弃
//type BundleInfoMongo struct {
//	BindingId      string `json:"bindingId" bson:"binding_id"`
//	BundleID       string `json:"bundleId" bson:"bundle_id"`
//	GroupID        string `json:"groupId" bson:"group_id"` //企业ID
//	Remark         string `json:"remark" bson:"remark"`
//	SDKKey         string `json:"SDKKey" bson:"sdk_key"`
//	SDKID          string `json:"SDKID" bson:"sdk_id"`
//	IsFirstCreate  string `json:"isFirstCreate" bson:"is_first_create"` //是否第一次创建
//	CreatedAt      int64  `json:"createdAt" bson:"created_at"`
//	CreatedAccount string `json:"createdAccount" bson:"created_account"`
//	CreatedBy      string `json:"createdBy" bson:"created_by"`
//}

// BundleInfoData 驼峰换下划线，给BindingMongo使用
type BundleInfoData struct {
	BundleID       string `json:"bundle_id" bson:"bundle_id"`
	Remark         string `json:"remark" bson:"remark"`
	SDKKey         string `json:"sdk_key" bson:"sdk_key"`
	SDKID          string `json:"sdk_id" bson:"sdk_id"`
	IsFirstCreate  bool   `json:"is_first_create" bson:"is_first_create"` //是否第一次创建
	CreatedAt      int64  `json:"created_at" bson:"created_at"`
	CreatedAccount string `json:"created_account" bson:"created_account"`
	CreatedBy      string `json:"created_by" bson:"created_by"`
	IsForbidden    int    `json:"is_forbidden" bson:"is_forbidden"`
	IsReview       int    `json:"is_review" bson:"is_review"`
}

type AppInfo struct {
	AppID        string `json:"appId" bson:"appId"`
	AssociatedAt int64  `json:"associatedAt" bson:"associatedAt"`
	AssociatedBy string `json:"associatedBy" bson:"associatedBy"`
}

type BindingMongo struct {
	BindingID                         string           `json:"bindingId" bson:"binding_id"`     //应用的id
	Name                              string           `json:"name" bson:"name"`                //应用名称
	BundleInfos                       []BundleInfoData `json:"bundleInfos" bson:"bundle_infos"` //bundle ids
	CreatedInfoBy                     string           `json:"createdInfoBy" bson:"created_info_by"`
	CreatedInfoAt                     int64            `json:"createdInfoAt" bson:"created_info_at"`
	CreatedInfoAccount                string           `json:"createdInfoAccount" bson:"created_info_account"`
	GroupID                           string           `json:"groupId" bson:"group_id"`     //企业ID
	GroupName                         string           `json:"groupName" bson:"group_name"` //企业名称（为了查询）
	CooperateStatusValue              string           `json:"cooperateStatusValue" bson:"cooperate_status_value"`
	CooperateStatusReason             string           `json:"cooperateStatusReason" bson:"cooperate_status_reason"`
	CooperateStatusLastUpdated        int64            `json:"cooperateStatusLastUpdated" bson:"cooperate_status_last_updated"`
	CooperateStatusModifiedBy         string           `json:"cooperateStatusModifiedBy" bson:"cooperate_status_modified_by"`
	CooperateValidStatusReason        string           `json:"cooperateValidStatusReason" bson:"cooperate_valid_status_reson"`
	CooperateValidStatusLastUpdated   int64            `json:"cooperateValidStatusLastUpdated" bson:"cooperate_valid_status_last_updated"`
	CooperateValidStatusModifiedBy    string           `json:"cooperateValidStatusModifiedBy" bson:"cooperate_valid_status_modified_by"`
	CooperateInvalidStatusReason      string           `json:"cooperateInvalidStatusReason" bson:"cooperate_invalid_status_reson"`
	CooperateInvalidStatusLastUpdated int64            `json:"cooperateInvalidStatusLastUpdated" bson:"cooperate_invalid_status_last_updated"`
	CooperateInvalidStatusModifiedBy  string           `json:"cooperateInvalidStatusModifiedBy" bson:"cooperate_invalid_status_modified_by"`
	AppInfos                          []AppInfo        `json:"appInfos" bson:"app_infos"` //appid 的信息
	Owner                             string           `json:"owner" bson:"owner"`        //所属企业
	Expire                            int64            `json:"expire" bson:"expire"`
	ApiServer                         string           `json:"apiServer" bson:"api_server"`          //子域名
	PlatForm                          int              `json:"platform" bson:"platform"`             //来源平台
	AutoBind                          int              `json:"autoBind" bson:"auto_bind"`            //自动关联小程序
	HiddenBundle                      int              `json:"hiddenBundle" bson:"hidden_bundle"`    //隐藏bundle信息
	FromBindingID                     string           `json:"fromBindingId" bson:"from_binding_id"` //来源ID
}

func (b BindingByMongoRepo) GetInfo(ctx context.Context, bindingId string) (*entity.Binding, error) {
	bindingMongo := BindingMongo{}
	err := bindingTable.GetOne(ctx, bson.M{"binding_id": bindingId}, &bindingMongo)
	if err != nil {
		return nil, err
	}

	result := convertBindingMongoToBinding(bindingMongo)

	return &result, err
}

func (b BindingByMongoRepo) GetByGroupIdAndName(ctx context.Context, groupId string, name string, isAdmin bool) (*entity.Binding, error) {
	bindingMongo := BindingMongo{}
	filter := bson.M{}
	if isAdmin {
		filter["group_id"] = groupId
		filter["name"] = name
		filter["platform"] = entity.BINGING_PLATFORM_OPER
	} else {
		filter["group_id"] = groupId
		filter["name"] = name
		filter["$or"] = []bson.M{{"platform": entity.BINGING_PLATFORM_ORGAN}, {"platform": bson.M{"$exists": false}}}
	}
	err := bindingTable.GetOne(ctx, filter, &bindingMongo)
	if err != nil {
		return nil, err
	}

	//bundleInfoMongos := make([]BundleInfoMongo, 0)
	//_, err = bindingTable.GetAll(ctx, bson.M{"binding_id": bindingMongo.BindingID}, []string{}, &bundleInfoMongos)
	//if err != nil {
	//	return nil, err
	//}
	//
	//result := convertBindingMongoToBinding(bindingMongo, bundleInfoMongos)
	result := convertBindingMongoToBinding(bindingMongo)

	return &result, err
}

func (b BindingByMongoRepo) GetByApiServer(ctx context.Context, apiServer string) (entity.Binding, error) {
	bindingMongo := BindingMongo{}
	res := entity.Binding{}

	err := bindingTable.GetOne(ctx, bson.M{"api_server": apiServer}, &bindingMongo)
	if err != nil {
		return res, err
	}

	//bundleInfoMongos := make([]BundleInfoMongo, 0)
	//_, err = bindingTable.GetAll(ctx, bson.M{"binding_id": bindingMongo.BindingID}, []string{}, &bundleInfoMongos)
	//if err != nil {
	//	return nil, err
	//}
	//
	//result := convertBindingMongoToBinding(bindingMongo, bundleInfoMongos)
	result := convertBindingMongoToBinding(bindingMongo)

	return result, err
}

func (b BindingByMongoRepo) GetInfoByParams(ctx context.Context, sdkKey, organId, appId string) (*entity.Binding, error) {
	bindingMongo := BindingMongo{}

	filters := []bson.M{}
	filters = append(filters, bson.M{"bundle_infos": bson.M{"$elemMatch": bson.M{"sdk_key": sdkKey}}}) //bson.M{"bundleInfos.SDKKey": bson.M{"$in": []string{sdkKey}}}
	if appId != "" {
		filters = append(filters, bson.M{"app_infos": bson.M{"$elemMatch": bson.M{"appId": appId}}})
	}
	if organId != "" {
		filters = append(filters, bson.M{"group_id": organId})
	}
	filter := bson.M{"$and": filters}

	err := bindingTable.GetOne(ctx, filter, &bindingMongo)
	if err != nil {
		return nil, err
	}
	result := convertBindingMongoToBinding(bindingMongo)

	return &result, err
}

func (b BindingByMongoRepo) GetInfoBySdkKeyOrganId(ctx context.Context, organId, sdkKey string) (*entity.Binding, error) {
	bindingMongo := BindingMongo{}
	err := bindingTable.GetOne(ctx, bson.M{"group_id": organId, "bundle_infos.sdk_key": sdkKey}, &bindingMongo)
	if err != nil {
		return nil, err
	}
	result := convertBindingMongoToBinding(bindingMongo)

	return &result, err
}

func (b BindingByMongoRepo) GetAllSdkKey(ctx context.Context, organId string) ([]string, error) {
	bindingMongos := make([]BindingMongo, 0)
	_, err := bindingTable.GetAll(ctx, bson.M{"group_id": organId}, []string{}, &bindingMongos)
	if err != nil {
		return nil, err
	}

	result := make([]string, 0)
	for _, v := range bindingMongos {
		//result := make([]string, 0)
		//bundleInfoMongos := make([]BundleInfoMongo, 0)
		//_, err = bundleInfoTable.GetAll(ctx, bson.M{"binding_id": v.BindingID}, []string{}, bundleInfoMongos)
		//if err != nil {
		//	return nil, err
		//}

		for _, bundleInfo := range v.BundleInfos {
			result = append(result, bundleInfo.SDKKey)
		}

	}

	return result, err
}

func (b BindingByMongoRepo) GetBindListBySdkKey(ctx context.Context, sdkKey string) ([]entity.Binding, error) {
	bindingMongos := make([]BindingMongo, 0)
	_, err := bindingTable.GetAll(ctx, bson.M{"bundle_infos.sdk_key": sdkKey}, []string{"created_info_at"}, &bindingMongos)
	if err != nil {
		return nil, err
	}

	bindings := make([]entity.Binding, 0)
	for _, bindingMongo := range bindingMongos {
		//bundleInfoMongos := make([]BundleInfoMongo, 0)
		//_, err = bundleInfoTable.GetAll(ctx, bson.M{"binding_id": bindingMongo.BindingID}, []string{}, bundleInfoMongos)
		//if err != nil {
		//	return nil, err
		//}

		//bindings = append(bindings, convertBindingMongoToBinding(bindingMongo, bundleInfoMongos))
		bindings = append(bindings, convertBindingMongoToBinding(bindingMongo))
	}

	return bindings, err
}

func (b BindingByMongoRepo) SdkKeyExi(ctx context.Context, sdkKey string) (bool, error) {
	if _, ok := entity.SdkExiCache.Get(sdkKey); ok {
		return true, nil
	}

	count, err := bindingTable.Count(ctx, bson.M{"bundle_infos.sdk_key": sdkKey})
	if err != nil {
		return false, err
	}

	if count > 0 {
		entity.SdkExiCache.Set(sdkKey, true, -1)
		return true, err
	}
	return false, err
}

func (b BindingByMongoRepo) Insert(ctx context.Context, bind *entity.Binding) error {
	err := bindingTable.Insert(ctx, convertBindingToBindingMongo(bind))
	if err != nil {
		return err
	}

	//for _, v := range bind.BundleInfos {
	//	err = bundleInfoTable.Insert(ctx, convertBundleInfoToBundleInfoMongo(bind.BindingID, bind.GroupID, v))
	//}

	return err
}

func (b BindingByMongoRepo) Count(ctx context.Context) (int, error) {
	return bindingTable.Count(ctx, bson.M{})
}

func (b BindingByMongoRepo) GetCountByStatus(ctx context.Context, status string, platform int) (int, error) {
	filter := bson.M{}
	filter["cooperate_status_value"] = "Valid"
	/*switch platform {
	case entity.BINGING_PLATFORM_OPER:
		filter["platform"] = entity.BINGING_PLATFORM_OPER
		filter["fromBindingId"] = ""
	case entity.BINGING_PLATFORM_ORGAN:
		filter["$or"] = []bson.M{{"platform": entity.BINGING_PLATFORM_ORGAN}, {"platform": bson.M{"$exists": false}}}
	default:
		filter["$or"] = []bson.M{{"platform": entity.BINGING_PLATFORM_OPER, "fromBindingId": ""}, {"$or": []bson.M{{"platform": entity.BINGING_PLATFORM_ORGAN}, {"platform": bson.M{"$exists": false}}}}}
	}*/
	filter["$or"] = []bson.M{{"platform": entity.BINGING_PLATFORM_OPER, "group_id": ""}, {"$or": []bson.M{{"platform": entity.BINGING_PLATFORM_ORGAN}, {"platform": bson.M{"$exists": false}}}}}
	return bindingTable.Count(ctx, filter)
}

func (b BindingByMongoRepo) GetBundleIdNum(ctx context.Context) (int, error) {
	//校验bundingId的数量
	pipSelect := []bson.M{
		{"$match": bson.M{"bundle_infos": bson.M{"$elemMatch": bson.M{"is_forbidden": 0}}}},
		{"$unwind": "$bundleInfos"},
		{"$group": bson.M{"_id": nil, "total": bson.M{"$sum": 1}}},
	}
	bundleIdTotal, err := bindingTable.AggregateCount(ctx, pipSelect)
	if err != nil && !b.NotFound(err) {
		log.Errorf("GetBundleIdNum err:", err.Error())
		return 0, err
	}
	if b.NotFound(err) {
		bundleIdTotal = 0
		return 0, nil
	}
	return bundleIdTotal, nil
}

func (b BindingByMongoRepo) GetBundleIdLimitHand(ctx context.Context, groupId string) (int, error) {
	//校验bundingId的数量
	pipSelect := []bson.M{
		//{"$match": bson.M{"group_id": groupId}},
		{"$match": bson.M{"group_id": groupId, "bundle_infos": bson.M{"$elemMatch": bson.M{"is_forbidden": 0}}}},
		{"$unwind": "$bundle_infos"},
		{"$group": bson.M{"_id": nil, "total": bson.M{"$sum": 1}}},
	}
	bundleIdTotal, err := bindingTable.AggregateCount(ctx, pipSelect)
	if err != nil && !b.NotFound(err) {
		return 0, err
	}
	if b.NotFound(err) {
		bundleIdTotal = 0
		return 0, nil
	}
	return bundleIdTotal, nil
}

func (b BindingByMongoRepo) GetBundleLimit(ctx context.Context) (int, error) {
	//return bundleTable.Count(ctx, bson.M{})
	return bundleTable.Count(ctx, bson.M{"is_forbidden": 0})
}

func (b BindingByMongoRepo) GetBindingByBindingId(ctx context.Context, bindingId string) (*entity.Binding, error) {
	bindingMongo := BindingMongo{}
	err := bindingTable.GetOne(ctx, bson.M{"binding_id": bindingId}, &bindingMongo)
	if err != nil {
		return nil, err
	}
	result := convertBindingMongoToBinding(bindingMongo)

	return &result, err
}
func (b BindingByMongoRepo) GetBindingByGroupIdAndBindingId(ctx context.Context, groupId string, bindingId string) (*entity.Binding, error) {
	bindingMongo := BindingMongo{}
	err := bindingTable.GetOne(ctx, bson.M{"group_id": groupId, "binding_id": bindingId}, &bindingMongo)
	if err != nil {
		return nil, err
	}

	//bundleInfoMongos := make([]BundleInfoMongo, 0)
	//_, err = bindingTable.GetAll(ctx, bson.M{"binding_id": bindingMongo.BindingID}, []string{}, &bundleInfoMongos)
	//if err != nil {
	//	return nil, err
	//}
	//
	//result := convertBindingMongoToBinding(bindingMongo, bundleInfoMongos)
	result := convertBindingMongoToBinding(bindingMongo)

	return &result, err
}

func (b BindingByMongoRepo) GetBindingByGroupIdAndSdkKey(ctx context.Context, groupId string, sdkKey string) (*entity.Binding, error) {
	bindingMongo := BindingMongo{}
	err := bindingTable.GetOne(ctx, bson.M{"group_id": groupId, "bundle_infos.sdk_key": sdkKey}, &bindingMongo)
	if err != nil {
		return nil, err
	}
	result := convertBindingMongoToBinding(bindingMongo)

	return &result, err
}

func (b BindingByMongoRepo) UpdateBundleInfosByGroupIdAndBindId(ctx context.Context, groupId string, bindingId string, infos []entity.BundleInfo) error {
	bundleInfoDatas := make([]BundleInfoData, 0)
	for _, v := range infos {
		bundleInfoData := BundleInfoData{
			BundleID:       v.BundleID,
			Remark:         v.Remark,
			SDKKey:         v.SDKKey,
			SDKID:          v.SDKID,
			IsFirstCreate:  v.IsFirstCreate,
			CreatedAt:      v.CreatedAt,
			CreatedAccount: v.CreatedAccount,
			CreatedBy:      v.CreatedBy,
			IsForbidden:    v.IsForbidden,
		}

		bundleInfoDatas = append(bundleInfoDatas, bundleInfoData)
	}
	return bindingTable.UpdateOne(ctx, bson.M{"group_id": groupId, "binding_id": bindingId}, bson.M{"$set": bson.M{"bundle_infos": bundleInfoDatas}})
}

func (b BindingByMongoRepo) AppendBundles(ctx context.Context, bindingId, groupId string, bundles []entity.BundleInfo) error {
	bindingInfo := BindingMongo{}
	err := bindingTable.GetOne(ctx, bson.M{"binding_id": bindingId}, &bindingInfo)
	if err != nil {
		return err
	}
	bundleInfoDatas := make([]BundleInfoData, 0)
	bundleInfoDatas = append(bundleInfoDatas, bindingInfo.BundleInfos...)
	for _, v := range bundles {
		bundleInfoData := BundleInfoData{
			BundleID:       v.BundleID,
			Remark:         v.Remark,
			SDKKey:         v.SDKKey,
			SDKID:          v.SDKID,
			IsFirstCreate:  v.IsFirstCreate,
			CreatedAt:      v.CreatedAt,
			CreatedAccount: v.CreatedAccount,
			CreatedBy:      v.CreatedBy,
			IsForbidden:    v.IsForbidden,
		}

		bundleInfoDatas = append(bundleInfoDatas, bundleInfoData)
	}
	return bindingTable.UpdateOne(ctx, bson.M{"binding_id": bindingId}, bson.M{"$set": bson.M{"bundle_infos": bundleInfoDatas}})
}

func (b BindingByMongoRepo) UpdateBundleIsView(ctx context.Context, reviews []apiproto.BundleReviewItem, isReview int) error {
	return nil
}

func (b BindingByMongoRepo) ListReviewBundle(ctx context.Context, pageSize int, pageNo int, searchText string, isReview int) (int64, []entity.ReviewBundleInfo, error) {
	return 0, nil, nil
}

func (b BindingByMongoRepo) CheckReviewBySdkKey(ctx context.Context, sdkKey string) bool {
	return false
}

func (b BindingByMongoRepo) GetReviewBindBySdkKey(ctx context.Context, sdkKey string) (*entity.ReviewBundleInfo, error) {
	return nil, nil
}

func (b BindingByMongoRepo) UpdateBundles(ctx context.Context, bindingId, groupId string, bundles []entity.BundleInfo) error {
	bundleInfoDatas := make([]BundleInfoData, 0)
	for _, v := range bundles {
		bundleInfoData := BundleInfoData{
			BundleID:       v.BundleID,
			Remark:         v.Remark,
			SDKKey:         v.SDKKey,
			SDKID:          v.SDKID,
			IsFirstCreate:  v.IsFirstCreate,
			CreatedAt:      v.CreatedAt,
			CreatedAccount: v.CreatedAccount,
			CreatedBy:      v.CreatedBy,
			IsForbidden:    v.IsForbidden,
			IsReview:       v.IsReview,
		}

		bundleInfoDatas = append(bundleInfoDatas, bundleInfoData)
	}
	return bindingTable.UpdateOne(ctx, bson.M{"binding_id": bindingId}, bson.M{"$set": bson.M{"bundle_infos": bundleInfoDatas}})
}

func (b BindingByMongoRepo) GetByBindIdList(ctx context.Context, ids []string) ([]entity.Binding, error) {
	bindingMongos := make([]BindingMongo, 0)
	_, err := bindingTable.GetAll(ctx, bson.M{"binding_id": bson.M{"$in": ids}}, []string{}, &bindingMongos)
	if err != nil {
		return nil, err
	}

	bindings := make([]entity.Binding, 0)
	for _, bindingMongo := range bindingMongos {
		//bundleInfoMongos := make([]BundleInfoMongo, 0)
		//_, err = bundleInfoTable.GetAll(ctx, bson.M{"binding_id": bindingMongo.BindingID}, []string{}, bundleInfoMongos)
		//if err != nil {
		//	return nil, err
		//}
		//
		//bindings = append(bindings, convertBindingMongoToBinding(bindingMongo, bundleInfoMongos))
		bindings = append(bindings, convertBindingMongoToBinding(bindingMongo))
	}

	return bindings, err
}

func (b BindingByMongoRepo) GetBindListByGroupId(ctx context.Context, groupId string, pageSize int, pageNo int) ([]entity.Binding, int, error) {
	bindingMongos := make([]BindingMongo, 0)
	filter := bson.M{"group_id": groupId}
	filter["$or"] = []bson.M{{"platform": entity.BINGING_PLATFORM_ORGAN}, {"platform": bson.M{"$exists": false}}}
	total, err := bindingTable.GetSome(ctx, filter, []string{"-created_info_at"}, pageSize, pageNo, &bindingMongos)
	if err != nil {
		return make([]entity.Binding, 0), 0, err
	}

	bindings := make([]entity.Binding, 0)
	for _, bindingMongo := range bindingMongos {
		//bundleInfoMongos := make([]BundleInfoMongo, 0)
		//_, err = bundleInfoTable.GetAll(ctx, bson.M{"binding_id": bindingMongo.BindingID}, []string{}, bundleInfoMongos)
		//if err != nil {
		//	return make([]entity.Binding, 0), 0, err
		//}
		//
		//bindings = append(bindings, convertBindingMongoToBinding(bindingMongo, bundleInfoMongos))
		bindings = append(bindings, convertBindingMongoToBinding(bindingMongo))
	}

	return bindings, total, err
}

func (b BindingByMongoRepo) UpdateRelatedBindingCooperate(ctx context.Context, bindingId string, status entity.Status, specificStatus entity.SpecificStatus, cooperate bool) error {
	if cooperate {
		return bindingTable.UpdateAll(ctx, bson.M{"from_binding_id": bindingId, "platform": entity.BINGING_PLATFORM_OPER},
			bson.M{"$set": bson.M{"cooperate_status_value": status.Value, "cooperate_status_last_updated": status.LastUpdated, "cooperate_status_modified_by": status.ModifiedBy,
				"cooperate_valid_status_last_updated": specificStatus.LastUpdated, "cooperate_valid_status_modified_by": specificStatus.ModifiedBy}})
	} else {
		return bindingTable.UpdateAll(ctx, bson.M{"from_binding_id": bindingId, "platform": entity.BINGING_PLATFORM_OPER},
			bson.M{"$set": bson.M{"cooperate_status_value": status.Value, "cooperate_status_last_updated": status.LastUpdated, "cooperate_status_modified_by": status.ModifiedBy,
				"cooperate_invalid_status_last_updated": specificStatus.LastUpdated, "cooperate_invalid_status_modified_by": specificStatus.ModifiedBy}})
	}
}

func (b BindingByMongoRepo) AppendApps(ctx context.Context, bindingId string, apps []entity.AppInfo) error {
	bindingInfo := BindingMongo{}
	err := bindingTable.GetOne(ctx, bson.M{"binding_id": bindingId}, &bindingInfo)
	if err != nil {
		return err
	}
	appsInfo := make([]AppInfo, 0)
	appsInfo = append(appsInfo, bindingInfo.AppInfos...)
	for _, v := range apps {
		app := AppInfo{
			AppID:        v.AppID,
			AssociatedAt: v.AssociatedAt,
			AssociatedBy: v.AssociatedBy,
		}

		appsInfo = append(appsInfo, app)
	}
	return bindingTable.UpdateOne(ctx, bson.M{"binding_id": bindingId}, bson.M{"$set": bson.M{"app_infos": appsInfo}})
}

func (b BindingByMongoRepo) RemoveApps(ctx context.Context, bindingId string, appIds []string) error {
	rmAppsMap := make(map[string]bool)
	for _, appId := range appIds {
		rmAppsMap[appId] = true
	}
	bindingInfo := BindingMongo{}
	err := bindingTable.GetOne(ctx, bson.M{"binding_id": bindingId}, &bindingInfo)
	if err != nil {
		return err
	}
	appsInfo := make([]AppInfo, 0)
	for _, app := range bindingInfo.AppInfos {
		if _, ok := rmAppsMap[app.AppID]; !ok {
			appsInfo = append(appsInfo, app)
		}
	}
	return bindingTable.UpdateOne(ctx, bson.M{"binding_id": bindingId}, bson.M{"$set": bson.M{"app_infos": appsInfo}})
}

func (b BindingByMongoRepo) UpdateByBindId(ctx context.Context, bindingId string, bind *entity.Binding) error {
	err := bindingTable.UpdateOne(ctx, bson.M{"binding_id": bindingId}, convertBindingToBindingMongo(bind))
	if err != nil {
		return err
	}

	//for _, v := range bind.BundleInfos {
	//	err = bundleInfoTable.UpdateOne(ctx, bson.M{"binding_id": bindingId}, convertBundleInfoToBundleInfoMongo(bind.BindingID, bind.GroupID, v))
	//}

	return err
}

func (b BindingByMongoRepo) UpdateBindingInfo(ctx context.Context, bindingId string, info map[string]interface{}, platform int) error {
	if platform == entity.BINGING_PLATFORM_OPER {
		err := bindingTable.UpdateOne(ctx, bson.M{"binding_id": bindingId}, bson.M{"$set": info})
		if err != nil {
			return err
		}
		return bindingTable.UpdateAll(ctx, bson.M{"from_binding_id": bindingId}, bson.M{"$set": info})
	} else {
		return bindingTable.UpdateOne(ctx, bson.M{"binding_id": bindingId}, bson.M{"$set": info})
	}
}

func (b BindingByMongoRepo) UpdateBindingGroupName(ctx context.Context, groupId, groupName string) error {
	return nil
}

func (b BindingByMongoRepo) UpdateExpire(ctx context.Context, bindingId string, expire int64) error {
	err := bindingTable.UpdateOne(ctx, bson.M{"binding_id": bindingId}, bson.M{"$set": bson.M{"expire": expire}})
	if err != nil {
		return err
	}

	return nil
}

func (b BindingByMongoRepo) BundleIdCount(ctx context.Context, groupId string) (int, error) {
	var pipSelect []bson.M
	if groupId == "" {
		pipSelect = []bson.M{
			{"$match": bson.M{"bundle_infos": bson.M{"$elemMatch": bson.M{"is_forbidden": 0}}}},
			{"$unwind": "$bundleInfos"},
			{"$group": bson.M{"_id": nil, "total": bson.M{"$sum": 1}}},
		}
	} else {
		pipSelect = []bson.M{
			{"$match": bson.M{"groupId": groupId, "bundle_infos": bson.M{"$elemMatch": bson.M{"is_forbidden": 0}}}},
			{"$unwind": "$bundleInfos"},
			{"$group": bson.M{"_id": nil, "total": bson.M{"$sum": 1}}},
		}
	}
	bundleIdTotal, err := bindingTable.AggregateCount(ctx, pipSelect)
	if err != nil && !b.NotFound(err) {
		log.Errorf("updateLicenseValid get bundle id count err:%s", err.Error())
		return 0, err
	}
	if b.NotFound(err) {
		bundleIdTotal = 0
		return 0, nil
	}
	return bundleIdTotal, nil
}

func (b BindingByMongoRepo) GetBundleByGroupIdAndBundleId(ctx context.Context, groupId string, bundleId string) (*entity.Binding, error) {
	//bundleInfoMongo := BundleInfoMongo{}
	//err := bundleInfoTable.GetOne(ctx, bson.M{"group_id": groupId, "bundle_id": bundleId}, &bundleInfoMongo)
	//if err != nil {
	//	return nil, err
	//}
	//
	//return convertBundleInfoMongoToBundleInfo(bundleInfoMongo), err

	bindingMongo := BindingMongo{}
	err := bindingTable.GetOne(ctx, bson.M{"group_id": groupId, "bundle_infos.bundle_id": bson.M{"$in": []string{bundleId}}}, &bindingMongo)
	if err != nil {
		return nil, err
	}

	result := convertBindingMongoToBinding(bindingMongo)

	return &result, err
}

func (b BindingByMongoRepo) GetbundlesByBundleId(ctx context.Context, bundleId string) (*entity.Binding, error) {
	//bundleInfoMongo := BundleInfoMongo{}
	//err := bundleInfoTable.GetOne(ctx, bson.M{"bundle_id": bundleId}, &bundleInfoMongo)
	//if err != nil {
	//	return nil, err
	//}
	//
	//return convertBundleInfoMongoToBundleInfo(bundleInfoMongo), err

	bindingMongo := BindingMongo{}
	err := bindingTable.GetOne(ctx, bson.M{"bundle_infos.bundle_id": bson.M{"$in": []string{bundleId}}}, &bindingMongo)
	if err != nil {
		return nil, err
	}

	result := convertBindingMongoToBinding(bindingMongo)

	return &result, err
}

func (b BindingByMongoRepo) GetBindingsBySearch(ctx context.Context, pageSize int, pageNo int, sort string, searchText string, searchFields string, cooperateStatus string, platform int) ([]entity.Binding, int, error) {
	bindingMongos := make([]BindingMongo, 0)

	sortColumn := make([]string, 0)
	switch sort {
	case "-created":
		sortColumn = append(sortColumn, "-created_info_at") //按创建时间排序
	case "-expire":
		sortColumn = append(sortColumn, "-expire") //按过期时间倒序排序
	case "expire":
		sortColumn = append(sortColumn, "expire") //按过期时间正序排序
	default:
		sortColumn = append(sortColumn, "-created_info_at") //按创建时间倒序排序
	}
	filter := []bson.M{}
	if searchText != "" && searchFields != "" {
		sf := bson.M{}
		r := bson.RegEx{Pattern: searchText, Options: "i"}
		searchFilter := make([]bson.M, 0)
		for _, v := range strings.Split(searchFields, ",") {
			searchFilter = append(searchFilter, bson.M{v: r})
		}
		sf["$or"] = searchFilter
		filter = append(filter, sf)
	}
	if cooperateStatus != "all" {
		q := bson.M{"cooperateStatus.value": cooperateStatus}
		filter = append(filter, q)
	}
	switch platform {
	case entity.BINGING_PLATFORM_OPER:
		filter = append(filter, bson.M{"platform": entity.BINGING_PLATFORM_OPER, "group_id": ""})
	case entity.BINGING_PLATFORM_ORGAN:
		q := bson.M{}
		q["$or"] = []bson.M{{"platform": entity.BINGING_PLATFORM_ORGAN}, {"platform": bson.M{"$exists": false}}}
		filter = append(filter, q)
	default:
		q := bson.M{}
		q["$or"] = []bson.M{{"platform": entity.BINGING_PLATFORM_OPER, "group_id": ""}, {"$or": []bson.M{{"platform": entity.BINGING_PLATFORM_ORGAN}, {"platform": bson.M{"$exists": false}}}}}
		filter = append(filter, q)
	}
	total, err := bindingTable.GetSome(ctx, bson.M{"$and": filter}, sortColumn, pageSize, pageNo, &bindingMongos)
	bindings := make([]entity.Binding, 0)
	for _, bindingMongo := range bindingMongos {
		bindings = append(bindings, convertBindingMongoToBinding(bindingMongo))
	}

	return bindings, total, err
}

func (b BindingByMongoRepo) GetBindingsByAppId(ctx context.Context, pageSize int, pageNo int, appId string) ([]entity.Binding, int, error) {
	bindingMongos := make([]BindingMongo, 0)

	filter := bson.M{"app_infos.appId": appId}

	total, err := bindingTable.GetSome(ctx, filter, []string{"-created_info_at"}, pageSize, pageNo, &bindingMongos)
	bindings := make([]entity.Binding, 0)
	for _, bindingMongo := range bindingMongos {
		bindings = append(bindings, convertBindingMongoToBinding(bindingMongo))
	}

	return bindings, total, err
}

func (b BindingByMongoRepo) GetDevListBinding(ctx context.Context, pageSize int, pageNo int, sort string, searchText string, pullType string, groupId string, bindStatus string, platform int) ([]entity.Binding, int, error) {
	bindingMongos := make([]BindingMongo, 0)

	sortColumn := make([]string, 0)
	switch sort {
	case "-created":
		sortColumn = append(sortColumn, "-created_info_at") //按创建时间排序
	case "-expire":
		sortColumn = append(sortColumn, "-expire") //按过期时间倒序排序
	case "expire":
		sortColumn = append(sortColumn, "expire") //按过期时间正序排序
	default:
		sortColumn = append(sortColumn, "-created_info_at") //按创建时间倒序排序
	}

	filter := []bson.M{}
	filter = append(filter, bson.M{"group_id": groupId})
	switch pullType {
	case "recently-expire":
		q := bson.M{}
		beginData := time.Now().UnixNano() / 1e6
		endData := time.Now().AddDate(0, 0, 30).UnixNano() / 1e6
		q["expire"] = bson.M{"$gte": beginData, "$lte": endData}
		filter = append(filter, q)
	}

	switch bindStatus {
	case "Valid":
		filter = append(filter, bson.M{"cooperate_status_value": "Valid"})
	case "Invalid":
		filter = append(filter, bson.M{"cooperate_status_value": "Invalid"})
	}
	if searchText != "" {
		q := bson.M{}
		r := bson.RegEx{Pattern: searchText, Options: "i"}
		q["$or"] = []bson.M{{"name": bson.M{"$regex": r}}}
		filter = append(filter, q)
	}
	switch platform {
	case entity.BINGING_PLATFORM_OPER:
		filter = append(filter, bson.M{"platform": entity.BINGING_PLATFORM_OPER})
	case entity.BINGING_PLATFORM_ORGAN:
		q := bson.M{}
		q["$or"] = []bson.M{{"platform": entity.BINGING_PLATFORM_ORGAN}, {"platform": bson.M{"$exists": false}}}
		filter = append(filter, q)
	default:
		q := bson.M{}
		q["$or"] = []bson.M{{"platform": entity.BINGING_PLATFORM_OPER}, {"$or": []bson.M{{"platform": entity.BINGING_PLATFORM_ORGAN}, {"platform": bson.M{"$exists": false}}}}}
		filter = append(filter, q)
	}
	total, err := bindingTable.GetSome(ctx, bson.M{"$and": filter}, sortColumn, pageSize, pageNo, &bindingMongos)
	bindings := make([]entity.Binding, 0)
	for _, bindingMongo := range bindingMongos {
		bindings = append(bindings, convertBindingMongoToBinding(bindingMongo))
	}

	return bindings, total, err
}

func (b BindingByMongoRepo) GetBindingBySdkKey(ctx context.Context, sdkKey string) (*entity.Binding, error) {
	bindingMongo := BindingMongo{}
	err := bindingTable.GetOne(ctx, bson.M{"bundle_infos.sdk_key": sdkKey}, &bindingMongo)
	if err != nil {
		return nil, err
	}
	result := convertBindingMongoToBinding(bindingMongo)

	return &result, err
}

func (b BindingByMongoRepo) ListAutoBindAppBinding(ctx context.Context, groupId string) ([]string, error) {
	bindingMongos := make([]BindingMongo, 0)
	_, err := bindingTable.GetAll(ctx, bson.M{"auto_bind": 1, "platform": entity.BINGING_PLATFORM_OPER, "group_id": groupId}, []string{}, &bindingMongos)
	if err != nil {
		return nil, err
	}
	result := []string{}
	for _, binding := range bindingMongos {
		result = append(result, binding.BindingID)
	}
	return result, nil
}

func (b BindingByMongoRepo) ListCopyOperBinding(ctx context.Context, bindingId string) ([]string, []entity.Binding, error) {
	bindingMongos := make([]BindingMongo, 0)
	_, err := bindingTable.GetAll(ctx, bson.M{"platform": entity.BINGING_PLATFORM_OPER, "from_binding_id": bindingId}, []string{}, &bindingMongos)
	if err != nil {
		return nil, nil, err
	}
	result := []string{}
	bindings := make([]entity.Binding, 0)
	for _, binding := range bindingMongos {
		result = append(result, binding.BindingID)
		bindings = append(bindings, convertBindingMongoToBinding(binding))
	}
	return result, bindings, nil
}

func (b BindingByMongoRepo) ListBindings(ctx context.Context, groupId string, searchText string, pageNo int, pageSize int) ([]entity.Binding, int, error) {
	bindingMongos := make([]BindingMongo, 0)

	sortColumn := make([]string, 0)
	sortColumn = append(sortColumn, "-created_info_at") //按创建时间排序
	filter := bson.M{}
	if groupId != "" {
		filter["group_id"] = groupId
	}

	if searchText != "" {
		r := bson.RegEx{Pattern: searchText, Options: "i"}
		filter["$or"] = []bson.M{{"name": r}, {"group_name": r}, {"bundle_infos.bundle_id": r}}
	}

	total, err := bindingTable.GetSome(ctx, filter, sortColumn, pageSize, pageNo, &bindingMongos)
	bindings := make([]entity.Binding, 0)
	for _, bindingMongo := range bindingMongos {
		bindings = append(bindings, convertBindingMongoToBinding(bindingMongo))
	}

	return bindings, total, err
}

func (b BindingByMongoRepo) GetAllAssBinds(ctx context.Context, appId string) ([]entity.Binding, error) {
	bindings := make([]BindingMongo, 0)
	err := bindingTable.OnlyGetAll(ctx, bson.M{"app_infos.appId": appId}, []string{}, &bindings)
	if err != nil {
		return nil, err
	}
	result := make([]entity.Binding, 0)
	for _, bindingMongo := range bindings {
		result = append(result, convertBindingMongoToBinding(bindingMongo))
	}
	return result, nil
}

func (b BindingByMongoRepo) NotFound(err error) bool {
	return err == mgo.ErrNotFound
}

func (b BindingByMongoRepo) UpdateBundleIdIsForbidden(ctx context.Context, bundleId string) error {
	return bindingTable.UpdateAll(ctx, bson.M{"bundle_infos": bson.M{"$elemMatch": bson.M{"bundle_id": bundleId}}}, bson.M{"$set": bson.M{"is_forbidden": 1}})
}

func (b BindingByMongoRepo) UpdateBundleIdPlatform(ctx context.Context, bundleId, platform string) error {
	return bindingTable.UpdateAll(ctx, bson.M{"bundle_infos": bson.M{"$elemMatch": bson.M{"bundle_id": bundleId}}}, bson.M{"$set": bson.M{"remark": platform}})
}

func (b BindingByMongoRepo) UpdateBundleBindingId(ctx context.Context, bundleId, bindingId, toBindingId string) error {
	return nil
}

func convertBindingMongoToBinding(bindingMongo BindingMongo) entity.Binding {
	result := entity.Binding{}

	bundleInfos := make([]entity.BundleInfo, 0)
	for _, v := range bindingMongo.BundleInfos {
		bundleInfo := entity.BundleInfo{
			BundleID:       v.BundleID,
			Remark:         v.Remark,
			SDKKey:         v.SDKKey,
			SDKID:          v.SDKID,
			IsFirstCreate:  v.IsFirstCreate,
			CreatedAt:      v.CreatedAt,
			CreatedAccount: v.CreatedAccount,
			CreatedBy:      v.CreatedBy,
			IsForbidden:    v.IsForbidden,
			IsReview:       v.IsReview,
		}

		bundleInfos = append(bundleInfos, bundleInfo)
	}
	appInfos := make([]entity.AppInfo, 0)
	for _, v := range bindingMongo.AppInfos {
		item := entity.AppInfo{
			AppID:        v.AppID,
			AssociatedAt: v.AssociatedAt,
			AssociatedBy: v.AssociatedBy,
		}
		appInfos = append(appInfos, item)
	}

	createInfo := entity.CreatedInfo{
		CreatedBy: bindingMongo.CreatedInfoBy,
		CreatedAt: bindingMongo.CreatedInfoAt,
	}

	cooperateStatus := entity.Status{
		Value:       bindingMongo.CooperateStatusValue,
		Reason:      bindingMongo.CooperateStatusReason,
		LastUpdated: bindingMongo.CooperateStatusLastUpdated,
		ModifiedBy:  bindingMongo.CooperateStatusModifiedBy,
	}

	cooperateValidStatus := entity.SpecificStatus{
		Reason:      bindingMongo.CooperateValidStatusReason,
		LastUpdated: bindingMongo.CooperateValidStatusLastUpdated,
		ModifiedBy:  bindingMongo.CooperateValidStatusModifiedBy,
	}

	cooperateInvalidStatus := entity.SpecificStatus{
		Reason:      bindingMongo.CooperateInvalidStatusReason,
		LastUpdated: bindingMongo.CooperateInvalidStatusLastUpdated,
		ModifiedBy:  bindingMongo.CooperateInvalidStatusModifiedBy,
	}

	//var appInfos []entity.AppInfo
	//json.Unmarshal([]byte(bindingMongo.AppInfos), &appInfos)

	result.BindingID = bindingMongo.BindingID
	result.Name = bindingMongo.Name
	result.BundleInfos = bundleInfos
	result.CreatedInfo = createInfo
	result.GroupID = bindingMongo.GroupID
	result.GroupName = bindingMongo.GroupName
	result.CooperateStatus = cooperateStatus
	result.CooperateValidStatus = cooperateValidStatus
	result.CooperateInvalidStatus = cooperateInvalidStatus
	result.AppInfos = appInfos
	result.Owner = bindingMongo.Owner
	result.Expire = bindingMongo.Expire
	result.ApiServer = bindingMongo.ApiServer
	result.PlatForm = bindingMongo.PlatForm
	result.AutoBind = bindingMongo.AutoBind
	result.HiddenBundle = bindingMongo.HiddenBundle
	result.FromBindingID = bindingMongo.FromBindingID
	return result
}

func convertBindingToBindingMongo(binding *entity.Binding) BindingMongo {
	result := BindingMongo{}

	bundleInfos := make([]BundleInfoData, 0)
	for _, v := range binding.BundleInfos {
		bundleInfo := BundleInfoData{
			BundleID:       v.BundleID,
			Remark:         v.Remark,
			SDKKey:         v.SDKKey,
			SDKID:          v.SDKID,
			IsFirstCreate:  v.IsFirstCreate,
			CreatedAt:      v.CreatedAt,
			CreatedAccount: v.CreatedAccount,
			CreatedBy:      v.CreatedBy,
			IsForbidden:    v.IsForbidden,
			IsReview:       v.IsReview,
		}

		bundleInfos = append(bundleInfos, bundleInfo)
	}

	result.BindingID = binding.BindingID
	result.Name = binding.Name
	result.BundleInfos = bundleInfos
	result.CreatedInfoBy = binding.CreatedInfo.CreatedBy
	result.CreatedInfoAt = binding.CreatedInfo.CreatedAt
	result.CreatedInfoAccount = binding.CreatedInfo.CreatedAccount
	result.GroupID = binding.GroupID
	result.GroupName = binding.GroupName
	result.CooperateStatusValue = binding.CooperateStatus.Value
	result.CooperateStatusReason = binding.CooperateStatus.Reason
	result.CooperateStatusLastUpdated = binding.CooperateStatus.LastUpdated
	result.CooperateStatusModifiedBy = binding.CooperateStatus.ModifiedBy
	result.CooperateValidStatusReason = binding.CooperateValidStatus.Reason
	result.CooperateValidStatusLastUpdated = binding.CooperateValidStatus.LastUpdated
	result.CooperateValidStatusModifiedBy = binding.CooperateValidStatus.ModifiedBy
	result.CooperateInvalidStatusReason = binding.CooperateInvalidStatus.Reason
	result.CooperateInvalidStatusLastUpdated = binding.CooperateInvalidStatus.LastUpdated
	result.CooperateInvalidStatusModifiedBy = binding.CooperateInvalidStatus.ModifiedBy
	appInfos := make([]AppInfo, 0)
	for _, v := range binding.AppInfos {
		item := AppInfo{
			AppID:        v.AppID,
			AssociatedAt: v.AssociatedAt,
			AssociatedBy: v.AssociatedBy,
		}
		appInfos = append(appInfos, item)
	}
	//result.AppInfos = utility.InterfaceToJsonString(binding.AppInfos)
	result.AppInfos = appInfos
	result.Owner = binding.Owner
	result.Expire = binding.Expire
	result.ApiServer = binding.ApiServer
	result.PlatForm = binding.PlatForm
	result.AutoBind = binding.AutoBind
	result.HiddenBundle = binding.HiddenBundle
	result.FromBindingID = binding.FromBindingID
	return result
}