package service

import (
	"blazing/common/utils"
	"blazing/cool"
	"blazing/modules/config/model"
	"fmt"
	"sort"
	"time"

	"github.com/gogf/gf/v2/container/gmap"
	"github.com/gogf/gf/v2/database/gdb"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/util/gconv"
	"github.com/qiniu/go-sdk/v7/auth/qbox"
	"github.com/qiniu/go-sdk/v7/storage"
)

type ServerService struct {
	*cool.Service
	manager *storage.BucketManager
	bucket  string
}

type ServerShowInfo struct {
	OnlineID   uint32            `json:"online_id"`
	Name       string            `json:"name"`
	IP         string            `json:"ip"`
	Port       uint32            `json:"port"`
	IsVip      uint32            `json:"is_vip"`
	IsDebug    uint8             `json:"is_debug"`
	IsOpen     uint8             `json:"is_open"`
	Owner      uint32            `json:"owner"`
	ExpireTime time.Time         `json:"expire_time"`
	ServerShow *model.ServerShow `json:"servershow,omitempty"`
}

func NewServerService() *ServerService {
	cf := &ServerService{
		Service: &cool.Service{
			Model: model.NewServerList(),
		},
	}
	cf.PageQueryOp = &cool.QueryOp{
		ModifyResult: func(ctx g.Ctx, data interface{}) interface{} {
			var rr []g.MapStrAny
			r, _ := gconv.Map(data)["list"].(gdb.Result)

			now := time.Now()
			serverIDs := make([]uint32, 0, len(r))
			for i := 0; i < len(r); i++ {
				serverID := gconv.Uint32(r[i].Map()["online_id"])
				if serverID == 0 {
					continue
				}
				serverIDs = append(serverIDs, serverID)
			}
			showMap := cf.getActiveServerShowMap(serverIDs, now)

			for i := 0; i < len(r); i++ {
				t, ok := cool.GetClient(gconv.Uint32(r[i].Map()["online_id"]), gconv.Uint32(r[i].Map()["port"]))
				subm := r[i].GMap()
				cf.applyServerShowMap(subm, gconv.Uint32(r[i].Map()["online_id"]), showMap)

				if ok {
					err := t.KickPerson(0) //实现指定服务器踢人
					if err == nil {
						r, _ := utils.TcpPing(fmt.Sprintf("%s:%d", r[i].Map()["ip"], r[i].Map()["port"]))
						subm.Set("isonline", r)
					} else {
						subm.Set("isonline", 0)
					}
				} else {
					subm.Set("isonline", 0)
				}
				rr = append(rr, subm.MapStrAny())
			}

			data.(map[string]interface{})["list"] = rr
			return data
		},
	}

	cfg := storage.Config{
		Zone:          &storage.ZoneHuadong,
		UseHTTPS:      true,
		UseCdnDomains: true,
	}
	mac := qbox.NewMac("DzMpomnPxqBHkIcvxTbC-hl_8LjVB0LXZuhCky_u", "bhoxrpG1s7MBmSS2I1k5t9zMpuiderpBDZoIPQKU")
	cf.bucket = "blazingt"
	cf.manager = storage.NewBucketManager(mac, &cfg)
	return cf
}

func (s *ServerService) GetPort(DepartmentID uint) []ServerShowInfo {
	servers := s.GetServer()
	items := make([]ServerShowInfo, 0, len(servers))
	for _, server := range servers {
		if server.IsOpen != 1 {
			continue
		}
		if DepartmentID == 1 && server.IsDebug != 0 {
			continue
		}
		items = append(items, ServerShowInfo{
			OnlineID:   server.OnlineID,
			Name:       server.Name,
			IP:         server.IP,
			Port:       server.Port,
			IsVip:      server.IsVip,
			IsDebug:    server.IsDebug,
			IsOpen:     server.IsOpen,
			Owner:      server.Owner,
			ExpireTime: server.ExpireTime,
			ServerShow: server.ServerShow,
		})
	}
	return items
}

func (s *ServerService) GetServer() []model.ServerList {
	var item []model.ServerList
	dbm_nocache_noenable(s.Model).With(model.ServerShow{}).Scan(&item)
	s.applyServerShowList(item, time.Now())
	return item
}

func (s *ServerService) StartUPdate(OnlineID uint16, isinstall int) model.ServerList {
	m := cool.DBM(s.Model).Where("online_id", OnlineID)
	var tttt model.ServerList
	m.Scan(&tttt)
	if isinstall == 1 {
		tttt.IsOpen = uint8(0)
		m.Save(tttt)
	}
	return tttt
}

func (s *ServerService) SetServerID(OnlineID uint32, Port uint32) error {
	m := cool.DBM(s.Model).Where("online_id", OnlineID)
	var tttt model.ServerList
	m.Scan(&tttt)
	tttt.Port = Port
	tttt.OnlineID = OnlineID
	tttt.IsOpen = 1
	m.Save(tttt)
	return nil
}

func (s *ServerService) GetServerID(OnlineID uint32) model.ServerList {
	var tttt model.ServerList
	dbm_nocache_noenable(s.Model).With(model.ServerShow{}).Where("online_id", OnlineID).Scan(&tttt)
	s.applyServerShow(&tttt, time.Now())
	return tttt
}

// GetDonationAvailableServerIDs 返回当前可被冠名占用的服务器ID列表。
func (s *ServerService) GetDonationAvailableServerIDs() []uint32 {
	servers := s.GetServer()
	now := time.Now()
	ids := make([]uint32, 0, len(servers))
	for _, server := range servers {
		if server.OnlineID == 0 {
			continue
		}
		if s.isActiveServerShow(server.ServerShow, now) {
			continue
		}
		ids = append(ids, server.OnlineID)
	}
	sort.Slice(ids, func(i, j int) bool { return ids[i] < ids[j] })
	return ids
}

// CanUseDonationName 校验目标服务器在当前时间点是否允许被冠名。
func (s *ServerService) CanUseDonationName(server model.ServerList, ownerID uint32, now time.Time) bool {
	if server.OnlineID == 0 {
		return false
	}
	if !s.isActiveServerShow(server.ServerShow, now) {
		return true
	}
	return server.ServerShow.Owner == ownerID
}

// 保存版本号
func (s *ServerService) SetServerScreen(id uint32, name string) {
	cool.DBM(s.Model).Where("online_id", id).Data("old_screen", name).Update()
}

func (s *ServerService) GetFile() string {
	var files []File
	prefix := "logic"
	delimiter := "" // 用于分隔目录
	marker := ""    // 初始标记为空
	for {
		entries, _, nextMarker, hasNext, err := s.manager.ListFiles(s.bucket, prefix, delimiter, marker, 100)
		if err != nil {
			return ""
		}
		for _, entry := range entries {
			files = append(files, File{
				Name: entry.Key,
				Size: entry.Fsize,
				Path: entry.Key,
				Time: entry.PutTime,
			})
		}
		if !hasNext {
			break
		}
		marker = nextMarker
	}

	sort.Slice(files, func(i, j int) bool {
		return files[i].Time > files[j].Time
	})
	if len(files) == 0 {
		return ""
	}
	return files[0].Name
}

type File struct {
	Name     string `json:"name"`
	Path     string `json:"path"`
	Url      string `json:"url"`
	Size     int64  `json:"size"`
	Modified string `json:"modified"`
	Time     int64  `json:"time"`
}

func (s *ServerService) isActiveServerShow(show *model.ServerShow, now time.Time) bool {
	if show == nil {
		return false
	}
	if show.ServerID == 0 || show.Owner == 0 {
		return false
	}
	if show.ExpireTime.IsZero() {
		return false
	}
	return show.ExpireTime.After(now)
}

func (s *ServerService) applyServerShowList(servers []model.ServerList, now time.Time) {
	for i := range servers {
		s.applyServerShow(&servers[i], now)
	}
}

func (s *ServerService) applyServerShow(server *model.ServerList, now time.Time) {
	if server == nil {
		return
	}
	server.Owner = 0
	server.ExpireTime = time.Time{}
	if !s.isActiveServerShow(server.ServerShow, now) {
		return
	}
	if server.ServerShow.Name != "" {
		server.Name = server.ServerShow.Name
	}
	server.Owner = server.ServerShow.Owner
	server.ExpireTime = server.ServerShow.ExpireTime
}

func (s *ServerService) getActiveServerShowMap(serverIDs []uint32, now time.Time) map[uint32]*model.ServerShow {
	showMap := make(map[uint32]*model.ServerShow, len(serverIDs))
	if len(serverIDs) == 0 {
		return showMap
	}
	var shows []model.ServerShow
	dbm_nocache_noenable(model.NewServerShow()).WhereIn("server_id", serverIDs).Scan(&shows)
	for i := range shows {
		show := &shows[i]
		if !s.isActiveServerShow(show, now) {
			continue
		}
		showMap[show.ServerID] = show
	}
	return showMap
}

func (s *ServerService) applyServerShowMap(serverMap *gmap.StrAnyMap, serverID uint32, showMap map[uint32]*model.ServerShow) {
	if serverMap == nil {
		return
	}
	serverMap.Set("owner", uint32(0))
	serverMap.Set("expire_time", time.Time{})
	show, ok := showMap[serverID]
	if !ok {
		return
	}
	if show.Name != "" {
		serverMap.Set("name", show.Name)
	}
	serverMap.Set("owner", show.Owner)
	serverMap.Set("expire_time", show.ExpireTime)
	serverMap.Set("servershow", show)
	return
}