package main

import (
	"bufio"
	"encoding/binary"
	"fmt"
	"image"
	"image/png"
	"math"
	"os"
	"sort"
	"strconv"

	"github.com/ethereum/go-ethereum/crypto"
)

var xs, ys, maxTime int
var minAbsTime, maxAbsTime int64

func set(pic *image.NRGBA, x, y, c, v int) {
	if v > 255 {
		v = 255
	}
	if x >= 0 && x < xs && y >= 0 && y < ys {
		pic.Pix[y*pic.Stride+x*4+c] = uint8(v)
	}
}

type nodeStats []struct{ wpSum, wpCnt, wpXcnt, regCnt, regXcnt uint64 }

type nodeInfo struct {
	maxMR  int
	topics map[string]struct{}
}

const (
	regStatDiv  = 60
	regStatYdiv = 30
)

type topicInfo struct {
	prefix    uint64
	nodes     uint64Slice
	nodeStats nodeStats
	nodeIdx   map[uint64]int
	pic, pic2 *image.NRGBA
	nodeRad   map[uint64]int
	regStats  []int
}

func main() {
	var nodes uint64Slice
	topics := make(map[string]*topicInfo)

	inputFile := "test.out"
	if len(os.Args) > 1 {
		inputFile = os.Args[1]
	}

	f, _ := os.Open(inputFile)
	scanner := bufio.NewScanner(f)
	scanner.Split(bufio.ScanWords)
	minAbsTime = math.MaxInt64
	for scanner.Scan() {
		w := scanner.Text()
		if w == "*N" {
			scanner.Scan()
			prefix, _ := strconv.ParseUint(scanner.Text(), 16, 64)
			nodes = append(nodes, prefix)
		}
		if w == "*R" {
			scanner.Scan()
			time, _ := strconv.ParseInt(scanner.Text(), 10, 64)
			if time > maxAbsTime {
				maxAbsTime = time
			}
			if time < minAbsTime {
				minAbsTime = time
			}
			scanner.Scan()
			topic := scanner.Text()
			if _, ok := topics[topic]; !ok {
				fmt.Println(topic)
				topicHash := crypto.Keccak256Hash([]byte(topic))
				topics[topic] = &topicInfo{prefix: binary.BigEndian.Uint64(topicHash[:8])}
			}
		}
	}
	f.Close()

	maxTime = int(maxAbsTime - minAbsTime)
	xs = maxTime / 10000
	ys = len(nodes)
	nodeIdx := make(map[uint64]int)
	for i, v := range nodes {
		nodeIdx[v] = i
	}
	nodeInfo := make([]nodeInfo, len(nodes))

	for _, t := range topics {
		t.nodes = make(uint64Slice, len(nodes))
		t.nodeStats = make(nodeStats, len(nodes))
		for i, v := range nodes {
			t.nodes[i] = v ^ t.prefix
		}
		sort.Sort(t.nodes)
		t.nodeIdx = make(map[uint64]int)
		for i, v := range t.nodes {
			t.nodeIdx[v^t.prefix] = i
		}

		t.pic = image.NewNRGBA(image.Rect(0, 0, xs, ys))
		for y := 0; y < ys; y++ {
			for x := 0; x < xs; x++ {
				set(t.pic, x, y, 3, 255)
			}
		}

		t.pic2 = image.NewNRGBA(image.Rect(0, 0, xs, ys))
		for y := 0; y < ys; y++ {
			for x := 0; x < xs; x++ {
				set(t.pic2, x, y, 3, 255)
			}
		}
		t.nodeRad = make(map[uint64]int)
		t.regStats = make([]int, xs/regStatDiv+1)
	}

	f, _ = os.Open(inputFile)
	scanner = bufio.NewScanner(f)
	scanner.Split(bufio.ScanWords)
	statBegin := int64(40000000)
	statEnd := int64(maxTime - 10000000)

	for scanner.Scan() {
		w := scanner.Text()
		if w == "*R" {
			scanner.Scan()
			time, _ := strconv.ParseInt(scanner.Text(), 10, 64)
			time -= minAbsTime
			scanner.Scan()
			t := topics[scanner.Text()]
			scanner.Scan()
			prefix, _ := strconv.ParseUint(scanner.Text(), 16, 64)
			scanner.Scan()
			rad, _ := strconv.ParseInt(scanner.Text(), 10, 64)
			if int(rad) != t.nodeRad[prefix] {
				t.nodeRad[prefix] = int(rad)
				radUint := uint64(rad) * ((^uint64(0)) / 1000000)
				x := int(time * int64(xs) / int64(maxTime))
				y := sort.Search(ys, func(i int) bool {
					return t.nodes[i] > radUint
				})
				set(t.pic, x, y, 1, 255)
			}
		}
		if w == "*MR" {
			scanner.Scan()
			time, _ := strconv.ParseInt(scanner.Text(), 10, 64)
			time -= minAbsTime
			scanner.Scan()
			topic := scanner.Text()
			t := topics[topic]
			scanner.Scan()
			prefix, _ := strconv.ParseUint(scanner.Text(), 16, 64)
			scanner.Scan()
			rad, _ := strconv.ParseInt(scanner.Text(), 10, 64)
			radUint := uint64(rad) * ((^uint64(0)) / 1000000)
			x := int(time * int64(xs) / int64(maxTime))
			y := sort.Search(ys, func(i int) bool {
				return t.nodes[i] > radUint
			})
			set(t.pic, x, y, 0, 255)
			ni := nodeInfo[nodeIdx[prefix]]
			if int(rad) > ni.maxMR {
				ni.maxMR = int(rad)
				if ni.topics == nil {
					ni.topics = make(map[string]struct{})
				}
				ni.topics[topic] = struct{}{}
			}
			nodeInfo[nodeIdx[prefix]] = ni
		}
		if w == "*W" {
			scanner.Scan()
			time, _ := strconv.ParseInt(scanner.Text(), 10, 64)
			time -= minAbsTime
			scanner.Scan()
			t := topics[scanner.Text()]
			scanner.Scan()
			prefix, _ := strconv.ParseUint(scanner.Text(), 16, 64)
			scanner.Scan()
			wp, _ := strconv.ParseInt(scanner.Text(), 10, 64)
			x := int(time * int64(xs) / int64(maxTime))
			y := t.nodeIdx[prefix]
			if time >= statBegin && time < statEnd {
				t.nodeStats[y].wpSum += uint64(wp)
				if wp >= 600000 {
					t.nodeStats[y].wpXcnt++
				}
				t.nodeStats[y].wpCnt++
			}
			/*set(t.pic2, x, y, 0, int(wp/100000))
			set(t.pic2, x, y, 1, int(wp/10000))
			set(t.pic2, x, y, 2, int(wp/1000))*/
			if wp >= 1800000 {
				set(t.pic2, x, y, 0, 255)
			}
			if wp >= 600000 {
				set(t.pic2, x, y, 1, 255)
			}
			if wp >= 60000 {
				set(t.pic2, x, y, 2, 255)
			}
		}
		if w == "*+" {
			scanner.Scan()
			time, _ := strconv.ParseInt(scanner.Text(), 10, 64)
			time -= minAbsTime
			scanner.Scan()
			t := topics[scanner.Text()]
			scanner.Scan()
			prefix, _ := strconv.ParseUint(scanner.Text(), 16, 64)
			x := int(time * int64(xs) / int64(maxTime))
			if x < xs {
				t.regStats[x/regStatDiv]++
			}
			y := t.nodeIdx[prefix]
			set(t.pic, x, y, 2, 255)
			scanner.Scan()
			prefix2, _ := strconv.ParseUint(scanner.Text(), 16, 64)
			y2 := t.nodeIdx[prefix2]
			if time >= statBegin && time < statEnd {
				t.nodeStats[y].regCnt++
				t.nodeStats[y2].regXcnt++
			}
		}
	}
	f.Close()

	for tt, t := range topics {
		f, _ = os.Create("test_" + tt + ".png")
		w := bufio.NewWriter(f)
		png.Encode(w, t.pic)
		w.Flush()
		f.Close()

		for x := 0; x < xs; x++ {
			yy := t.regStats[x/regStatDiv] / regStatYdiv
			if yy > ys {
				yy = ys
			}
			for y := 0; y < yy; y++ {
				set(t.pic2, x, ys-1-y, 1, 255)
			}
		}

		f, _ = os.Create("test2_" + tt + ".png")
		w = bufio.NewWriter(f)
		png.Encode(w, t.pic2)
		w.Flush()
		f.Close()

		if statEnd > statBegin {
			xxs := len(t.nodeStats)
			yys := 1000
			yyh := yys / 2
			pic3 := image.NewNRGBA(image.Rect(0, 0, xxs, yys))
			for y := 0; y < yys; y++ {
				for x := 0; x < xxs; x++ {
					set(pic3, x, y, 3, 255)
				}
			}
			for x := 0; x < xxs; x++ {
				wpy := 0
				if t.nodeStats[x].wpCnt > 0 {
					//					wpy = int(t.nodeStats[x].wpSum / t.nodeStats[x].wpCnt / 10000)
					wpy = int(uint64(yyh) * t.nodeStats[x].wpXcnt / t.nodeStats[x].wpCnt)
				}
				if wpy > yyh {
					wpy = yyh
				}
				for y := 0; y < wpy; y++ {
					set(pic3, x, yys-1-y, 1, 255)
				}
				regy := int(t.nodeStats[x].regCnt * 2400000 / uint64(statEnd-statBegin))
				if regy > yyh {
					regy = yyh
				}
				for y := 0; y < regy; y++ {
					set(pic3, x, yyh-1-y, 2, 255)
				}
				regy2 := int(t.nodeStats[x].regXcnt * 2400000 / uint64(statEnd-statBegin))
				if regy2 > yyh {
					regy2 = yyh
				}
				for y := 0; y < regy2; y++ {
					set(pic3, x, yyh-1-y, 0, 255)
				}
			}

			f, _ = os.Create("test3_" + tt + ".png")
			w = bufio.NewWriter(f)
			png.Encode(w, pic3)
			w.Flush()
			f.Close()
		}
	}

	for i, ni := range nodeInfo {
		fmt.Printf("%d %016x  maxMR = %d  ", i, nodes[i], ni.maxMR)
		for t, _ := range ni.topics {
			fmt.Printf(" %s", t)
		}
		fmt.Println()
	}
}

type uint64Slice []uint64

// Len is the number of elements in the collection.
func (s uint64Slice) Len() int {
	return len(s)
}

// Less reports whether the element with
// index i should sort before the element with index j.
func (s uint64Slice) Less(i, j int) bool {
	return s[i] < s[j]
}

// Swap swaps the elements with indexes i and j.
func (s uint64Slice) Swap(i, j int) {
	s[i], s[j] = s[j], s[i]
}