package krpc

import (
	"encoding/json"
	"fmt"
	"io"
	"net"
	"sync"

	"krwu.top/krpc.v1/client"
	"krwu.top/krpc.v1/codec"
)

type Server struct{}

func NewServer() *Server {
	return &Server{}
}

var DefaultServer = NewServer()

func (s *Server) Accept(lis net.Listener) {
	for {
		conn, err := lis.Accept()
		if err != nil {
			fmt.Println("rpc server: accept error: ", err)
			return
		}
		go s.ServeConn(conn)
	}
}

func (s *Server) ServeConn(conn io.ReadWriteCloser) {
	defer func() {
		_ = conn.Close()
	}()
	var opts client.Options
	if err := json.NewDecoder(conn).Decode(&opts); err != nil {
		fmt.Println("rpc server: options error: ", err)
		return
	}
	if opts.MagicNumber != codec.MagicNumber {
		fmt.Printf("rpc server: invalid magic number %x\n", opts.MagicNumber)
		return
	}
	f := codec.NewCodecFuncMap[opts.CodecType]
	if f == nil {
		fmt.Printf("rpc server: invalid codec type %s\n", opts.CodecType)
		return
	}
	s.ServeCodec(f(conn))
}

var invalidRequest = struct{}{}

func (s *Server) ServeCodec(cc codec.Codec) {
	sending := new(sync.Mutex)
	wg := new(sync.WaitGroup)
	for {
		req, err := s.readRequest(cc)
		if err != nil {
			fmt.Println("rpc server invalid request: ", err)
			if req == nil {
				break
			}
			req.h.Error = err.Error()
			s.sendResponse(cc, req.h, invalidRequest, sending)
			continue
		}
		wg.Add(1)
		go s.handleRequest(cc, req, sending, wg)
	}
	wg.Wait()
	_ = cc.Close()
}

func Accept(lis net.Listener) { DefaultServer.Accept(lis) }