package main

import (
	"context"
	"log"
	"net"
	"net/http"
	_ "net/http/pprof"

	vnc "github.com/vtolstov/go-vnc"
)

func main() {
	go func() {
		log.Println(http.ListenAndServe(":6060", nil))
	}()

	ln, err := net.Listen("tcp", ":5900")
	if err != nil {
		log.Fatalf("Error listen. %v", err)
	}

	schClient := make(chan vnc.ClientMessage)
	schServer := make(chan vnc.ServerMessage)

	scfg := &vnc.ServerConfig{
		Width:           800,
		Height:          600,
		VersionHandler:  vnc.ServerVersionHandler,
		SecurityHandler: vnc.ServerSecurityHandler,
		SecurityHandlers: []vnc.SecurityHandler{
			&vnc.ClientAuthVeNCrypt02Plain{Username: []byte("test"), Password: []byte("test")},
			&vnc.ClientAuthNone{},
		},
		ClientInitHandler: vnc.ServerClientInitHandler,
		ServerInitHandler: vnc.ServerServerInitHandler,
		Encodings: []vnc.Encoding{
			&vnc.TightPngEncoding{},
			&vnc.CopyRectEncoding{},
			&vnc.RawEncoding{},
		},
		PixelFormat:     vnc.PixelFormat32bit,
		ClientMessageCh: schClient,
		ServerMessageCh: schServer,
		ClientMessages:  vnc.DefaultClientMessages,
		DesktopName:     []byte("vnc proxy"),
	}
	c, err := net.Dial("tcp", "127.0.0.1:5995")
	if err != nil {
		log.Fatalf("Error dial. %v", err)
	}
	cchServer := make(chan vnc.ServerMessage)
	cchClient := make(chan vnc.ClientMessage)

	ccfg := &vnc.ClientConfig{
		VersionHandler:    vnc.ClientVersionHandler,
		SecurityHandler:   vnc.ClientSecurityHandler,
		SecurityHandlers:  []vnc.SecurityHandler{&vnc.ClientAuthNone{}},
		ClientInitHandler: vnc.ClientClientInitHandler,
		ServerInitHandler: vnc.ClientServerInitHandler,
		PixelFormat:       vnc.PixelFormat32bit,
		ClientMessageCh:   cchClient,
		ServerMessageCh:   cchServer,
		ServerMessages:    vnc.DefaultServerMessages,
		Encodings:         []vnc.Encoding{&vnc.RawEncoding{}},
	}

	cc, err := vnc.Connect(context.Background(), c, ccfg)
	if err != nil {
		log.Fatalf("Error dial. %v", err)
	}

	go vnc.Serve(context.Background(), ln, scfg)

	defer cc.Close()
	go cc.Handle()

	for {
		select {
		case msg := <-cchServer:
			schServer <- msg
		case msg := <-schClient:
			switch msg.Type() {
			case vnc.SetEncodingsMsgType:
				var encTypes []vnc.EncodingType
				for _, senc := range scfg.Encodings {
					for _, cenc := range msg.(*vnc.SetEncodings).Encodings {
						if cenc == senc.Type() {
							encTypes = append(encTypes, senc.Type())
						}
					}
				}
				cchClient <- &vnc.SetEncodings{Encodings: encTypes}
			default:
				cchClient <- msg
			}
		}
	}
}