package main

import (
	"bufio"
	"encoding/json"
	"fmt"
	"log"
	"net"
	"time"
)

type Server struct {
	URL  string
	Port int
}

type Client struct {
	Address string
	conn    net.Conn
	bufRW   *bufio.ReadWriter
}

type ConversationID int

const (
	ConversationOne ConversationID = iota + 1
	ConversationTwo
	ConversationThree
	ConversationEnd
)

type Msg struct {
	ID   ConversationID `json:"ID"`
	Body string         `json:"Body"`
}

var serverMsg map[ConversationID]string
var clientMsg map[ConversationID]string

func init() {
	serverMsg = make(map[ConversationID]string)
	serverMsg[ConversationOne] = "吃了没，您呐？"
	serverMsg[ConversationThree] = "嗨，没事儿溜溜弯儿。"
	serverMsg[ConversationEnd] = "回头去给老太太请安！"
	clientMsg = make(map[ConversationID]string)
	clientMsg[ConversationOne] = "开场"
	clientMsg[ConversationTwo] = "刚吃。"
	clientMsg[ConversationThree] = "您这，嘛去？"
	clientMsg[ConversationEnd] = "有空家里坐坐啊"
}

func (s *Server) Listen() error {
	address := fmt.Sprintf("%s:%d", s.URL, s.Port)
	tcpAddr, _ := net.ResolveTCPAddr("tcp", address)
	ln, err := net.ListenTCP("tcp", tcpAddr)
	if err != nil {
		log.Printf("server: failed to listen %s, err: %s", address, err)
		return err
	}
	for {
		conn, err := ln.AcceptTCP()
		if err != nil {
			log.Printf("server: failed to connect %s, err: %s", address, err)
			return err
		}
		go s.msgHandler(conn)
	}
}

func (s *Server) msgHandler(conn net.Conn) {
	rw := bufio.NewReadWriter(bufio.NewReader(conn), bufio.NewWriter(conn))
	for {
		buf, err := rw.ReadBytes('\n')
		if err != nil {
			log.Printf("server: client disconnect")
			conn.Close()
			return
		}
		msg := Msg{}
		err = json.Unmarshal(buf, &msg)
		if err != nil {
			log.Println("server: json unmarshal failed")
			continue
		}

		// log.Println("client: ", msg.Body)
		if res, ok := serverMsg[msg.ID]; ok {
			replyMsg := Msg{
				ID:   msg.ID,
				Body: res,
			}
			replyBytes, err := json.Marshal(&replyMsg)
			replyBytes = append(replyBytes, []byte("\n")...)
			if err != nil {
				log.Println("server: json marshal failed, err: ", err)
				continue
			}
			rw.Write(replyBytes)
			rw.Flush()
		} else {
			continue
		}
	}
}

func (c *Client) Connect() (err error) {
	c.conn, err = net.Dial("tcp", c.Address)
	if err != nil {
		log.Printf("client: connect to %s failed", c.Address)
		return err
	}
	c.bufRW = bufio.NewReadWriter(bufio.NewReader(c.conn), bufio.NewWriter(c.conn))
	return nil
}

func (c *Client) SendMsg() {
	curID := ConversationOne
	for curID <= ConversationEnd {
		body := ""
		if res, ok := clientMsg[curID]; ok {
			body = res
		} else {
			log.Println("not found msg, id: ", curID)
			return
		}
		msg := Msg{
			ID:   curID,
			Body: body,
		}
		msgBytes, err := json.Marshal(&msg)
		if err != nil {
			log.Println("client: json marshal failed, err: ", err)
			return
		}
		msgBytes = append(msgBytes, []byte("\n")...)
		_, err = c.bufRW.Write(msgBytes)
		if err != nil {
			fmt.Println("write failed, err: ", err)
			continue
		}
		c.bufRW.Flush()
		if curID == ConversationTwo {
			curID++
			continue
		}
		replyBytes, _ := c.bufRW.ReadBytes('\n')
		replyMsg := Msg{}
		if err := json.Unmarshal(replyBytes, &replyMsg); err != nil {
			log.Println("client: json unmarshal failed, err: ", err)
			return
		}
		// log.Println("server: ", replyMsg.Body)
		curID++
	}
}

func (c *Client) Stop() {
	c.conn.Close()
}

func main() {
	s := Server{
		URL:  "127.0.0.1",
		Port: 8000,
	}
	go func() {
		if err := s.Listen(); err != nil {
			panic(err)
		}
	}()
	time.Sleep(2 * time.Second)
	c := Client{
		Address: "127.0.0.1:8000",
	}
	if err := c.Connect(); err != nil {
		panic(err)
	}
	go func() {
		defer c.Stop()
		start := time.Now()
		for i := 0; i < 100000; i++ {
			c.SendMsg()
		}
		elapse := time.Since(start)
		log.Println("total spend: ", elapse)
	}()
	<-(chan int)(nil)
}