package main

import (
    "bufio"
    "fmt"
    "log"
    "net"
    "strings"
    "sync"
)

type Server struct {
    mutex sync.RWMutex
    peers map[string]*Peer
}

type Peer struct {
    conn    net.Conn
    server  *Server
    msgchan chan []byte
}

func NewServer() *Server {
    return &Server{
        peers: make(map[string]*Peer),
    }
}

func NewPeer(conn net.Conn, server *Server) *Peer {
    return &Peer{
        conn:    conn,
        server:  server,
        msgchan: make(chan []byte, 1),
    }
}

func (s *Server) AddPeer(port string, conn net.Conn) *Peer {

    s.mutex.Lock()

    peer := NewPeer(conn, s)

    s.peers[port] = peer

    s.mutex.Unlock()

    return peer
}

func (s *Server) HandlePeer(conn net.Conn) {

    port := strings.Split((conn).RemoteAddr().String(), ":")[1]

    peer := &Peer{}

    if _, ok := s.peers[port]; !ok {
        peer = s.AddPeer(port, conn)
        fmt.Println("added peer")
    }

    go peer.readMsg()

    go peer.writeMsg()
}

func (p *Peer) readMsg() {

    conn := p.conn

    for {

        fmt.Println(conn.RemoteAddr().String())

        msg, err := bufio.NewReader(conn).ReadString('\n')

        if err != nil {
            fmt.Println(err)
            continue
        }

        msg = strings.TrimSuffix(msg, "\r\n")

        p.msgchan <- []byte(msg)
    }
}

func (p *Peer) MsgPeer(msg []byte) error {

    conn := p.conn

    fmt.Println(p.conn)

    _, err := conn.Write(msg)

    if err != nil {
        return err
    }

    return nil
}

func (p *Peer) handleGetPeers() {

    for port := range p.server.peers {
        p.MsgPeer([]byte(port + "\n"))
    }
}

func (p *Peer) writeMsg() {

    for m := range p.msgchan {

        msg := string(m)

        fmt.Printf("msg: %s recieved from: %s\n", msg, p.conn.RemoteAddr().String())

        switch msg {
        case "get_peers":
            p.handleGetPeers()
        }
    }
}

func main() {

    server := NewServer()

    listener, err := net.Listen("tcp", ":1337")

    if err != nil {
        log.Fatal(err)
    }

    for {

        conn, err := listener.Accept()

        if err != nil {
            fmt.Println(err)
            continue
        }

        go server.HandlePeer(conn)
    }
}