package main

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

// TCP4Server will open listeners and create Go Handlers
func TCP4Server(port int) {
	service := "127.0.0.1:" + strconv.Itoa(port)
	fmt.Printf("Trying to server on %s\n\n", service)

	listener, err := net.Listen("tcp4", service)
	checkError(err)
	defer listener.Close()
	for {
		c, err := listener.Accept()
		checkError(err)
		go ServerHandler(c)
	}

}

func read(c net.Conn, ch chan []byte) {
	data := make([]byte, 0, 16384)
	tmp := make([]byte, 256)

	for {
		size, err := c.Read(tmp)

		if err != nil {
			if err == io.EOF {
				break
			}
			fmt.Printf("\n\n\n### Error on read %v", err)
			os.Exit(1)
		}
		data = append(data, tmp[:size]...)
		if size < 256 {
			ch <- data
		}
	}
}

// ServerHandler will receive data from the socket and answer to it
func ServerHandler(c net.Conn) {

	p := NewProxy()
	ip := "192.168.100.4"
	p.SetAddrAndPort(ip, 22)
	p.OpenConnection()
	p.CheckError()

	chServer := make(chan []byte, 10)
	chClient := make(chan []byte, 10)

	sServer := make(chan []byte, 10)
	sClient := make(chan []byte, 10)

	for {
		go p.ReadAll(chServer)
		go read(c, chClient)

		select {
		case d := <-chClient:
			sServer <- d
			p.WriteBytes(sServer)
			fmt.Printf("\n\n-->Client: %s", string(d))
		case d := <-chServer:
			sClient <- d
			write(c, sClient)
			fmt.Printf("\n\n-->SSH Server: %s", string(d))
		default:
			fmt.Println("server...")

		}
		time.Sleep(30 * time.Millisecond)
	}
}

func write(c net.Conn, ch chan []byte) {
	select {
	case d := <-ch:
		c.Write(d)
	}

}

func checkError(err error) {
	if err != nil {
		fmt.Printf("\n\n\n### Error: %v", err)
		os.Exit(1)
	}
}

func main() {
	/*if len(os.Args) != 3 {
		fmt.Println("usage: %s ip-address\n", os.Args[0])
		os.Exit(1)
	}*/

	//port, _ := strconv.Atoi(os.Args[2])
	//OpenRequestIPV4(os.Args[1], port)

	TCP4Server(15232)

}