package ims_user

import (
	"fmt"
	"strconv"
	"strings"

	"be.ems/src/framework/database/redis"
	neService "be.ems/src/modules/network_element/service"
)

// 实例化服务层 Service 结构体
var NewVoLTEService = &Service{
	volteRepository: NewVoLTERepository,
}

// VoLTE用户信息 服务层处理
type Service struct {
	volteRepository *Repository // VoLTE用户信息数据信息
}

// dataByRedis UDM签约用户 db:0 中 volte:*
func (r *Service) dataByRedis(imsi, neId string) []VoLTEUser {
	arr := []VoLTEUser{}
	key := fmt.Sprintf("volte:%s", imsi)
	source := fmt.Sprintf("UDM_%s", neId)

	// 网元主机的Redis客户端
	redisClient, err := neService.NewNeInfo.NeRunRedisClient("UDM", neId)
	if err != nil {
		return arr
	}
	defer func() {
		redisClient.Close()
		redis.ConnectPush(source, nil)
	}()
	redis.ConnectPush(source, redisClient.Client)

	udmsdArr, err := redis.GetKeys(source, key)
	if err != nil {
		return arr
	}
	mkv, err := redis.GetHashBatch(source, udmsdArr)
	if err != nil {
		return arr
	}

	for k, m := range mkv {
		var imsi, msisdn string
		KeyParts := strings.Split(k, ":")
		switch len(KeyParts) {
		case 0, 1:
			// 处理单个部分的情况
			continue
		case 2:
			// 处理两个部分的情况
			imsi = KeyParts[1]
			msisdn = "-"
		case 3:
			// 处理三个部分的情况
			imsi = KeyParts[1]
			msisdn = KeyParts[2]
		default:
			// 处理更多部分的情况
			imsi = KeyParts[1]
			msisdn = KeyParts[2]
		}

		var vni string = "-"
		impiParts := strings.Split(m["impi"], "@")
		if len(impiParts) > 1 {
			vni = impiParts[1] // 输出: ims.mnc001.mcc110.3gppnetwork.org
		}
		a := VoLTEUser{
			NeId:   neId,
			IMSI:   imsi,     // volte:360000100000130:8612300000130
			MSISDN: msisdn,   // 8612300000130
			Tag:    m["tag"], // volte = tag
			VNI:    vni,      //  ims.mnc001.mcc110.3gppnetwork.org
		}
		arr = append(arr, a)
	}
	return arr
}

// ResetData 重置鉴权用户数据，清空数据库重新同步Redis数据
func (r *Service) ResetData(neId string) int64 {
	subArr := r.dataByRedis("*", neId)
	// 数据清空后添加
	go r.volteRepository.ClearAndInsert(neId, subArr)
	return int64(len(subArr))
}

// ParseInfo 解析单个用户imsi签约信息 data从命令MML得到的结果
func (r *Service) ParseInfo(imsi, neId string, data map[string]string) VoLTEUser {
	u := r.volteRepository.SelectByIMSIAndNeID(imsi, neId)

	msisdn := data["msisdn"]
	if imsMsisdnLen := strings.Index(msisdn, ","); imsMsisdnLen != -1 {
		msisdn = msisdn[:imsMsisdnLen]
	}

	// 用于更新
	u.NeId = neId
	u.IMSI = imsi
	u.MSISDN = msisdn
	u.Tag = data["volte_tag"]
	u.VNI = data["VNI"]
	return u
}

// SelectPage 分页查询数据库
func (r *Service) SelectPage(query map[string]any) map[string]any {
	return r.volteRepository.SelectPage(query)
}

// SelectList 查询数据库
func (r *Service) SelectList(u VoLTEUser) []VoLTEUser {
	return r.volteRepository.SelectList(u)
}

// Insert 从数据中读取后删除imsi再存入数据库
// imsi长度15，ki长度32，opc长度0或者32
func (r *Service) Insert(neId string, u VoLTEUser) int64 {
	uArr := r.dataByRedis(u.IMSI, neId)
	if len(uArr) > 0 {
		r.volteRepository.Delete(u.IMSI, neId)
		return r.volteRepository.Inserts(uArr)
	}
	return 0
}

// InsertData 导入文件数据 dataType目前两种：txt/csv
func (r *Service) InsertData(neId, dataType string, data any) int64 {
	// imsi截取前缀,重新获取部分数据
	prefixes := make(map[string]struct{})

	if dataType == "csv" {
		for _, v := range data.([]map[string]string) {
			imsi := v["imsi"]
			if len(imsi) < 6 {
				continue
			}
			prefix := imsi[:len(imsi)-4]
			prefixes[prefix] = struct{}{}
		}
	}
	if dataType == "txt" {
		for _, v := range data.([][]string) {
			imsi := v[0]
			if len(imsi) < 6 {
				continue
			}
			prefix := imsi[:len(imsi)-4]
			prefixes[prefix] = struct{}{}
		}
	}

	// 根据前缀重新加载插入
	var num int64 = 0
	for prefix := range prefixes {
		// keys volte:4600001000004*
		arr := r.dataByRedis(prefix+"*", neId)
		if len(arr) > 0 {
			r.volteRepository.DeletePrefixByIMSI(prefix, neId)
			num += r.volteRepository.Inserts(arr)
		}
	}
	return num
}

// Delete 删除单个不重新加载
func (r *Service) Delete(neId, imsi string) int64 {
	return r.volteRepository.Delete(imsi, neId)
}

// LoadData 重新加载从imsi开始num的数据
func (r *Service) LoadData(neId, imsiOrMsisdn, num string) {
	startIMSIOrMsisdn, _ := strconv.ParseInt(imsiOrMsisdn, 10, 64)
	subNum, _ := strconv.ParseInt(num, 10, 64)
	var i int64
	for i = 0; i < subNum; i++ {
		keyIMSI := fmt.Sprintf("%015d", startIMSIOrMsisdn+i)
		if !strings.HasPrefix(imsiOrMsisdn, "0") {
			keyIMSI = fmt.Sprintf("%d", startIMSIOrMsisdn+i)
		}
		// 删除原数据
		r.volteRepository.Delete(keyIMSI, neId)
		arr := r.dataByRedis(keyIMSI, neId)
		if len(arr) < 1 {
			continue
		}
		r.volteRepository.Inserts(arr)
	}
}

// ParseCommandParams 解析数据组成命令参数 msisdn=xx,xx=xx,...
func (r *Service) ParseCommandParams(item VoLTEUser) string {
	var conditions []string
	if item.MSISDN != "" {
		conditions = append(conditions, fmt.Sprintf("msisdn=%s", item.MSISDN))
	}

	if item.Tag != "" {
		conditions = append(conditions, fmt.Sprintf("volte=%s", item.Tag))
	}
	if item.VNI != "" {
		conditions = append(conditions, fmt.Sprintf("vni=%s", item.VNI))
	}

	return strings.Join(conditions, ",")
}
