package main

import (
    "bufio"
    "fmt"
    "io"
    "net"
    "os"
    "strconv"
)

func main() {
    l, err := net.ListenTCP("tcp4", &net.TCPAddr{net.IPv4zero, 3080})
    if l == nil {
        fmt.Printf("cannot listen: %s\n", err)
        os.Exit(1)
    }

    fmt.Printf("listening at %s\n", l.Addr())

    for {
        conn, err := l.AcceptTCP()
        if conn == nil {
            fmt.Printf("accept error: %s\n", err)
            l.Close()
            os.Exit(1)
        }
        fmt.Printf("connection from %s\n", conn.RemoteAddr())

        h := new(Handler)
        h.conn = conn
        h.addr = conn.RemoteAddr()

        go h.main()
    }
}

var nl byte = 10

type Handler struct {
    conn *net.TCPConn
    rw   *bufio.ReadWriter
    addr net.Addr
}

func (self *Handler) main() {
    conn := self.conn
    rw := bufio.NewReadWriter(bufio.NewReader(self.conn), bufio.NewWriter(conn))
    defer conn.Close()

    self.rw = rw

    defer func() {
        if e := recover(); e != nil {
            fmt.Println(e)
        }
    }()

    for {
        s := self.readLine()
        s2 := self.readLine()

        dist, _ := levenshtein(s, s2)

        fmt.Println("dist is ", dist)

        rw.WriteString(strconv.Itoa(dist))
        rw.WriteString(string(nl))

        rw.Flush()
    }
}

func (self *Handler) readLine() string {
    s, err := self.rw.ReadString(nl)

    if len(s) > 0 {
        return s
    } else if err == io.EOF {
        panic(fmt.Sprintf("conn %s eof\n", self.addr))
    } else {
        panic(fmt.Sprintf("error reading: %s\n", err))
    }

    return ""
}