package net

import (
	"bufio"
	"fmt"
	"net"
)

type Head struct {
	Length 		int32
	Cmd 		int32
	ErrCode 	int32
	PreField    int32
}


type Connection struct {
	net.Conn
	Id int
	Server *Server

	scanner *bufio.Scanner
	writer *bufio.Writer

	WBuffer chan []byte
	RBuffer chan *MsgPkg

	Quit chan *Connection
}

type MsgPkg struct {
	Head Head
	Body []byte
	Conn *Connection
}

func NewConn(id int, conn net.Conn, s *Server) *Connection {
	return &Connection{
		Id: id,
		Conn: conn,
		Server: s,

		scanner: bufio.NewScanner(conn),
		writer: bufio.NewWriter(conn),
		WBuffer: make(chan []byte),
		RBuffer: make(chan *MsgPkg),
		Quit: make(chan *Connection),
	}
}

func (c *Connection) write()  {
	defer c.Quiting()

	for msg := range c.WBuffer {
		if _, err := c.writer.Write(msg); err != nil {
			fmt.Println("write fail err: " + err.Error())
			return
		}
		if err := c.writer.Flush(); err != nil {
			fmt.Println("write Flush fail err: " + err.Error())
			return
		}
	}
}

func (c *Connection) read() {
	defer c.Quiting()
	for  {
		c.scanner.Split(ParseMsg)

		for c.scanner.Scan() {
			req, err := DecodeMsg(c.scanner.Bytes())
			if err != nil {
				return
			}

			req.Conn = c
			c.Server.OnRecv(req)
		}

		if err := c.scanner.Err(); err != nil {
			fmt.Printf("scanner.err: %s\n", err.Error())
			c.Quiting()
			return
		}
	}
}

func (c *Connection) Start()  {
	go c.write()
	go c.read()
}

func (c *Connection) Stop()  {
	close(c.RBuffer)
	close(c.WBuffer)
	c.Conn.Close()
}

func (c *Connection) Quiting()  {
	c.Server.OnClose(c)
}

func (c *Connection) SendMsg(){
}