package ntripcaster

import (
	"fmt"
	"net"
	"sync"
	"time"

	"gitee.com/unignss/ntrip/internal"
)

type TcpListener struct {
	mu sync.RWMutex

	// 0:Not started, 1:Started
	state int8

	listener       net.Listener
	network        string
	addr           string
	errmsg         string
	isTerminated   bool
	HandleConnFunc func(conn net.Conn)
	OnErr          func(err error)
	OnListenSucc   func(network, addr string)
}

func NewTcpListener() *TcpListener {
	rval := &TcpListener{}
	return rval
}

func (this *TcpListener) Active() bool {
	return this.state == 1
}

func (this *TcpListener) Config(network, addr string) bool {
	rval := false
	if this.network != network {
		this.network = network
		rval = true
	}

	if this.addr != addr {
		this.addr = addr
		rval = true
	}
	if rval {
		this.mu.RLock()
		ls := this.listener
		this.mu.RUnlock()
		if ls != nil {
			ls.Close()
		}
	}
	return rval
}

//	1: Listen success
//
// -1: Listen failed
//
//	0: Not started
func (this *TcpListener) Status() int {
	if this.state == 0 {
		return 0
	}
	this.mu.RLock()
	defer this.mu.RUnlock()
	if this.listener != nil {
		return 1
	} else {
		return -1
	}
}

func (this *TcpListener) StatusString() string {
	if this.state == 0 {
		return "Not started"
	}
	this.mu.RLock()
	defer this.mu.RUnlock()
	ls := this.listener
	if ls != nil {
		return fmt.Sprintf("[%s]Listen success", ls.Addr().String())
	} else {
		return this.errmsg
	}
}

func (this *TcpListener) CheckStart() {
	this.mu.Lock()
	defer this.mu.Unlock()
	if this.state != 0 {
		return
	}
	this.isTerminated = false
	go this.open()
}

func (this *TcpListener) Close() error {
	this.mu.Lock()
	if this.state == 0 {
		this.mu.Unlock()
		return net.ErrClosed
	}
	this.isTerminated = true
	ls := this.listener
	this.listener = nil
	this.mu.Unlock()
	if ls != nil {
		return ls.Close()
	}
	return nil
}

func (this *TcpListener) Open() {
	this.mu.Lock()
	if this.state != 0 {
		this.mu.Unlock()
		return
	}
	this.isTerminated = false
	this.mu.Unlock()
	this.open()
}

func (this *TcpListener) open() {
begin:
	this.mu.Lock()
	if this.isTerminated {
		this.mu.Unlock()
		return
	}
	this.state = 1
	this.mu.Unlock()

	var listener net.Listener
	var err error

	if len(this.addr) == 0 || len(this.network) == 0 {
		this.errmsg = fmt.Sprintf("[%s]Invalid connection parameter configuration, network:%s, addr:%s", internal.NowString(), this.network, this.addr)
		if this.OnErr != nil {
			this.OnErr(fmt.Errorf("Invalid connection parameter configuration, network:%s, addr:%s", this.network, this.addr))
		}
		time.Sleep(time.Second * 1)
		goto begin
	}
	listener, err = net.Listen(this.network, this.addr)
	if err != nil {
		this.errmsg = fmt.Sprintf("[%s]Listen failed, network:%s, addr:%s, %s", internal.NowString(), this.network, this.addr, err.Error())
		if this.OnErr != nil {
			this.OnErr(err)
		}
		time.Sleep(time.Second * 1)
		goto begin
	} else {
		evt := this.OnListenSucc
		if evt != nil {
			evt(this.network, listener.Addr().String())
		}
	}

	this.mu.Lock()
	this.listener = listener
	this.mu.Unlock()

	for {
		client, err := listener.Accept()
		if err != nil {
			if this.OnErr != nil {
				this.OnErr(err)
			}
			listener.Close()
			goto begin
		}

		if this.HandleConnFunc != nil {
			this.HandleConnFunc(client)
		}
	}
}