package main

import "fmt"
import "log"
import "net"
import "os"
import "io"
import "bytes"
import "strconv"

import "github.com/golang/protobuf/proto"
import pb "git.wit.com/wit/witProtobuf"

import "github.com/andlabs/ui"
import _ "github.com/andlabs/ui/winmanifest"

import "git.wit.com/wit/gui"

var mychannel chan *pb.Event

func initChannel() {
	mychannel = make(chan *pb.Event)
}

// func processEvents(mychannel chan *pb.Event) {
func processEvents() {
	for {
		message := <-mychannel
		log.Println("processEvents() on channel recieved a message = ", message)
		if (message.Type == pb.Event_DEMO) {
			log.Println("processEvents() do Event DEMO")
			go ui.Main(gui.SetupDemoUI)
		} else {
			mh := addVmsTab(30)
			ReadReceivedData(message, mh)
		}
	}
}

func ReadReceivedData(data *pb.Event, mh *gui.TableData) {
	msgItems := data.GetResults()
	log.Println("ReadReceivedData() Event msgItems=", msgItems)
	for _, item := range msgItems {
		log.Println(item)
	}

	nets := data.GetNetworks()
	log.Println("ReadReceivedData() Event networks=", nets)
	for _, item := range nets {
		log.Println(item)
	}

	vms := data.GetVms()
	log.Println("ReadReceivedData() Event vms=", vms)
	for row, item := range vms {
		if (row % 2) == 1 {
			mh.Rows[row].HumanData[0].Color  = ui.TableColor{0, 0, 0, .04}
		} else {
			mh.Rows[row].HumanData[0].Color  = ui.TableColor{0, 0, 0, 0}
		}
		mh.Rows[row].HumanData[1].Text  = ui.TableString(item.Name)
		mh.Rows[row].HumanData[1].Color = ui.TableColor{0, 0, 0, 0}
		mh.Rows[row].HumanData[2].Text  = ui.TableString(item.Hostname)
		mh.Rows[row].HumanData[2].Color = ui.TableColor{0, 0, 0, 0}
		mh.Rows[row].HumanData[3].Text  = ui.TableString(fmt.Sprintf("%d",item.Cpus))
		mh.Rows[row].HumanData[3].Color = ui.TableColor{0, 0, 0, 0}
		mh.Rows[row].HumanData[4].Text  = ui.TableString(fmt.Sprintf("%d",item.Memory))
		mh.Rows[row].HumanData[4].Color = ui.TableColor{0, 0, 0, 0}
		mh.Rows[row].HumanData[5].Text  = ui.TableString(fmt.Sprintf("%d",item.Disk))
		mh.Rows[row].HumanData[5].Color = ui.TableColor{0, 0, 0, 0}
		mh.Rows[row].HumanData[6].Text  = ui.TableString(fmt.Sprintf("Details %s",item.Name))

		log.Println("\titem=", item)
		log.Println("\titem.Name=", item.Name)
		log.Println("\tRows[row]=", mh.Rows[row])
		log.Println("\tRows[row]=", row)
		log.Println("\tRows[row].Name=", mh.Rows[row].Name)
		log.Println(item)
		row += 1
	}

/*
	log.Println("ReadReceivedData() mh rows")
	for row := 0; row < mh.RowCount; row++ {
		log.Println("\trow=", row)
		log.Println("\tRows[row]=", mh.Rows[row])
	}
*/
}

func addSampleEvent() {
	msg := pb.CreateSampleEvent()
	msg.Name = "generated in addSampleEvent()"

	addEvent(msg)
}

// Marshal & Unmarshal just to see if it ever fails
func addEvent(msg *pb.Event) {
	data, err := proto.Marshal(msg)
	if (err != nil) {
		log.Printf("addEvent() something fucked up happened in Marshal")
	}

	pdata := new(pb.Event)
        err = proto.Unmarshal(data, pdata)
	if (err != nil) {
		log.Printf("addEvent() something fucked up happened in Unmarshal")
	}

	mychannel <- pdata
}

func sendDataToDest() {
	msg := pb.CreateSampleEvent()
	msg.Name = "from dnssecsockettest()"

	data, err := proto.Marshal(msg)
	if (err != nil) {
		log.Printf("something fucked up happened")
	}

	conn, err := net.Dial("tcp", "localhost:8080")
	if err != nil {
		log.Println("Fatal error: %s", err.Error())
		return
	}
	n, err := conn.Write(data)
	if err != nil {
		// fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())
		log.Println("Fatal error: %s", err.Error())
		return
	}

	pb.DumpEventData(msg)
	log.Println("Sent " + strconv.Itoa(n) + " bytes")
	// time.Sleep(3 * 1000 * 1000 * 1000)
	conn.Close()
}

func handleProtoClient(conn net.Conn) {
	fmt.Println("Connected!")
	defer conn.Close()
	var buf bytes.Buffer
	_, err := io.Copy(&buf, conn)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())
		return
	}
	pdata := pb.CreateSampleEvent()
	err = proto.Unmarshal(buf.Bytes(), pdata)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())
		return
	}
	mychannel <- pdata
}