package notify

import (
	"context"
	"errors"
	"fmt"
	"math/rand"
	"net"
	"strings"
	"sync"
	"time"

	"b612.me/starcrypto"
	"b612.me/starnet"
)

// StarNotifyC 为Client端
type StarNotifyC struct {
	Connc       net.Conn
	dialTimeout time.Duration
	clientSign  map[string]chan string
	mu          sync.Mutex
	// FuncLists 当不使用channel时，使用此记录调用函数
	FuncLists   map[string]func(CMsg)
	stopSign    context.Context
	cancel      context.CancelFunc
	defaultFunc func(CMsg)
	// UseChannel 是否使用channel作为信息传递
	UseChannel bool
	isUDP      bool
	Sync       bool
	// Queue 是用来处理收发信息的简单消息队列
	Queue *starnet.StarQueue
	// Online 当前链接是否处于活跃状态
	Online   bool
	lockPool map[string]CMsg
	aesKey   []byte
}

// CMsg 指明当前客户端被通知的关键字
type CMsg struct {
	Key   string
	Value string
	mode  string
	wait  chan int
}

func WriteToUDP(local *net.UDPConn, remote *net.UDPAddr, data []byte) error {
	var MAX_RECV_LEN = 8192
	var haveErr error
	end := len(data)
	for i := 0; i < end; i += MAX_RECV_LEN {
		step := i + MAX_RECV_LEN
		if step > end {
			step = end
		}
		_, err := local.WriteToUDP(data[i:step], remote)
		if err != nil {
			haveErr = err
		}
	}
	return haveErr
}

func (star *StarNotifyC) starinitc() {
	builder := starnet.NewQueue()
	builder.EncodeFunc = encodeFunc
	builder.DecodeFunc = decodeFunc
	builder.Encode = true
	star.stopSign, star.cancel = context.WithCancel(context.Background())
	star.Queue = builder
	star.FuncLists = make(map[string]func(CMsg))
	star.UseChannel = false
	star.clientSign = make(map[string]chan string)
	star.Online = false
	star.lockPool = make(map[string]CMsg)
	star.Queue.RestoreDuration(time.Millisecond * 50)
}

func (star *StarNotifyC) SetAesKey(key []byte) {
	star.aesKey = key
	star.Queue.EncodeFunc = func(data []byte) []byte {
		return starcrypto.AesEncryptCFB(data, key)
	}
	star.Queue.DecodeFunc = func(data []byte) []byte {
		return starcrypto.AesDecryptCFB(data, key)
	}
}

func (star *StarNotifyC) GetAesKey() []byte {
	if len(star.aesKey) == 0 {
		return aesKey
	}
	return star.aesKey
}

// Notify 用于获取一个通知
func (star *StarNotifyC) Notify(key string) chan string {
	if _, ok := star.clientSign[key]; !ok {
		ch := make(chan string, 20)
		star.mu.Lock()
		star.clientSign[key] = ch
		star.mu.Unlock()
	}
	return star.clientSign[key]
}

func (star *StarNotifyC) store(key, value string) {
	if _, ok := star.clientSign[key]; !ok {
		ch := make(chan string, 20)
		ch <- value
		star.mu.Lock()
		star.clientSign[key] = ch
		star.mu.Unlock()
		return
	}
	star.clientSign[key] <- value
}
func NewNotifyCWithTimeOut(netype, value string, timeout time.Duration) (*StarNotifyC, error) {
	var err error
	var star StarNotifyC
	star.starinitc()
	star.isUDP = false
	if strings.Index(netype, "udp") >= 0 {
		star.isUDP = true
	}
	star.Connc, err = net.DialTimeout(netype, value, timeout)
	if err != nil {
		return nil, err
	}
	star.dialTimeout = timeout
	go star.cnotify()
	go func() {
		<-star.stopSign.Done()
		star.Connc.Close()
		star.Online = false
		return
	}()
	go func() {
		for {
			buf := make([]byte, 8192)
			n, err := star.Connc.Read(buf)
			if n != 0 {
				star.Queue.ParseMessage(buf[0:n], star.Connc)
			}
			if err != nil {
				star.Connc.Close()
				star.ClientStop()
				//star, _ = NewNotifyC(netype, value)
				star.Online = false
				return
			}
		}
	}()
	star.Online = true
	return &star, nil
}

// NewNotifyC 用于新建一个Client端进程
func NewNotifyC(netype, value string) (*StarNotifyC, error) {
	var err error
	var star StarNotifyC
	star.starinitc()
	star.isUDP = false
	if strings.Index(netype, "udp") >= 0 {
		star.isUDP = true
	}
	star.Connc, err = net.Dial(netype, value)
	if err != nil {
		return nil, err
	}
	go star.cnotify()
	go func() {
		<-star.stopSign.Done()
		star.Connc.Close()
		star.Online = false
		return
	}()
	go func() {
		for {
			buf := make([]byte, 8192)
			n, err := star.Connc.Read(buf)
			if n != 0 {
				star.Queue.ParseMessage(buf[0:n], star.Connc)
			}
			if err != nil {
				star.Connc.Close()
				star.ClientStop()
				//star, _ = NewNotifyC(netype, value)
				star.Online = false
				return
			}
		}
	}()
	star.Online = true
	return &star, nil
}

// Send 用于向Server端发送数据
func (star *StarNotifyC) Send(name string) error {
	return star.SendValue(name, "")
}

func (star *StarNotifyC) Stoped() <-chan struct{} {
	return star.stopSign.Done()
}

func (star *StarNotifyC) SendValueRaw(key string, msg interface{}) error {
	encodeData, err := encode(msg)
	if err != nil {
		return err
	}
	return star.SendValue(key, string(encodeData))
}

// SendValue 用于向Server端发送key-value类型数据
func (star *StarNotifyC) SendValue(name, value string) error {
	var err error
	var key []byte
	for _, v := range []byte(name) {
		if v == byte(124) || v == byte(92) {
			key = append(key, byte(92))
		}
		key = append(key, v)
	}
	_, err = star.Connc.Write(star.Queue.BuildMessage([]byte("pa" + "||" + string(key) + "||" + value)))
	return err
}

func (star *StarNotifyC) trim(name string) string {
	var slash bool = false
	var key []byte
	for _, v := range []byte(name) {
		if v == byte(92) && !slash {
			slash = true
			continue
		}
		slash = false
		key = append(key, v)
	}
	return string(key)
}
func (star *StarNotifyC) SendValueWaitRaw(key string, msg interface{}, tmout time.Duration) (CMsg, error) {
	encodeData, err := encode(msg)
	if err != nil {
		return CMsg{}, err
	}
	return star.SendValueWait(key, string(encodeData), tmout)
}

// SendValueWait 用于向Server端发送key-value类型数据并等待结果返回，此结果不会通过标准返回流程处理
func (star *StarNotifyC) SendValueWait(name, value string, tmout time.Duration) (CMsg, error) {
	var err error
	var tmceed <-chan time.Time
	if star.UseChannel {
		return CMsg{}, errors.New("Do Not Use UseChannel Mode!")
	}
	rand.Seed(time.Now().UnixNano())
	mode := "cr" + fmt.Sprintf("%d%06d", time.Now().UnixNano(), rand.Intn(999999))
	var key []byte
	for _, v := range []byte(name) {
		if v == byte(124) || v == byte(92) {
			key = append(key, byte(92))
		}
		key = append(key, v)
	}
	_, err = star.Connc.Write(star.Queue.BuildMessage([]byte(mode + "||" + string(key) + "||" + value)))
	if err != nil {
		return CMsg{}, err
	}
	if int64(tmout) > 0 {
		tmceed = time.After(tmout)
	}
	var source CMsg
	source.wait = make(chan int, 2)
	star.mu.Lock()
	star.lockPool[mode] = source
	star.mu.Unlock()
	select {
	case <-source.wait:
		res := star.lockPool[mode]
		star.mu.Lock()
		delete(star.lockPool, mode)
		star.mu.Unlock()
		return res, nil
	case <-tmceed:
		return CMsg{}, errors.New("Time Exceed")
	}
}

// ReplyMsg 用于向Server端Reply信息
func (star *StarNotifyC) ReplyMsg(data CMsg, name, value string) error {
	var err error
	var key []byte
	for _, v := range []byte(name) {
		if v == byte(124) || v == byte(92) {
			key = append(key, byte(92))
		}
		key = append(key, v)
	}
	_, err = star.Connc.Write(star.Queue.BuildMessage([]byte(data.mode + "||" + string(key) + "||" + value)))
	return err
}

func (star *StarNotifyC) cnotify() {
	for {
		select {
		case <-star.stopSign.Done():
			return
		default:
		}
		data, err := star.Queue.RestoreOne()
		if err != nil {
			time.Sleep(time.Millisecond * 500)
			continue
		}
		if string(data.Msg) == "b612ryzstop" {
			star.ClientStop()
			star.Online = false
			return
		}
		strs := strings.SplitN(string(data.Msg), "||", 3)
		if len(strs) < 3 {
			continue
		}
		strs[1] = star.trim(strs[1])
		if star.UseChannel {
			go star.store(strs[1], strs[2])
		} else {
			mode, key, value := strs[0], strs[1], strs[2]
			if mode[0:2] != "cr" {
				if msg, ok := star.FuncLists[key]; ok {
					if star.Sync {
						msg(CMsg{key, value, mode, nil})
					} else {
						go msg(CMsg{key, value, mode, nil})
					}
				} else {
					if star.defaultFunc != nil {
						if star.Sync {
							star.defaultFunc(CMsg{key, value, mode, nil})
						} else {
							go star.defaultFunc(CMsg{key, value, mode, nil})
						}
					}
				}
			} else {
				if sa, ok := star.lockPool[mode]; ok {
					sa.Key = key
					sa.Value = value
					sa.mode = mode
					star.mu.Lock()
					star.lockPool[mode] = sa
					star.mu.Unlock()
					sa.wait <- 1
				} else {
					if msg, ok := star.FuncLists[key]; ok {
						if star.Sync {
							msg(CMsg{key, value, mode, nil})
						} else {
							go msg(CMsg{key, value, mode, nil})
						}
					} else {
						if star.defaultFunc != nil {
							if star.Sync {
								star.defaultFunc(CMsg{key, value, mode, nil})
							} else {
								go star.defaultFunc(CMsg{key, value, mode, nil})
							}
						}
					}
				}
			}
		}
	}
}

// ClientStop 终止client端运行
func (star *StarNotifyC) ClientStop() {
	if star.isUDP {
		star.Send("b612ryzstop")
	}
	star.cancel()
}

// SetNotify 用于设置关键词的调用函数
func (star *StarNotifyC) SetNotify(name string, data func(CMsg)) {
	star.FuncLists[name] = data
}

// SetDefaultNotify 用于设置默认关键词的调用函数
func (star *StarNotifyC) SetDefaultNotify(data func(CMsg)) {
	star.defaultFunc = data
}