package main

import (
	"encoding/json"
	"fmt"
	"log"
	"time"

)

type odbDemo struct {
	g *odb.Gutil
}

func (demo *odbDemo) graph() {
	//ret, _, err := g.Query(`match ('biz:b1')-[:contain]->()-[:contain]->()`)
	ret, meta, err := demo.g.Query(`match ('biz:查账系统')-[*]->() until 'router:router1','router:router2'`)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Meta:")
	mb, err := json.MarshalIndent(meta, "", "  ")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(mb))

	fmt.Println("Data:")
	b, err := json.MarshalIndent(ret, "", "  ")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(b))

	fmt.Println(len(ret[0]["graph"].(*odb.CypherGraph).Edges))

	if len(ret) != 0 {
		var endPoints []string
		allSource := make(map[string]struct{})
		allTarget := make(map[string]struct{})
		graph := ret[0]["graph"].(*odb.CypherGraph)
		for _, edge := range graph.Edges {
			fmt.Println(edge["source"])
			allSource[edge["source"].(string)] = struct{}{}
			allTarget[edge["target"].(string)] = struct{}{}
		}
		fmt.Println(allSource)
		fmt.Println(allTarget)
		for targetID := range allTarget {
			if _, ok := allSource[targetID]; !ok {
				endPoints = append(endPoints, targetID)
			}
		}
		fmt.Println(endPoints)
		fmt.Print(len(ret[0]["graph"].(*odb.CypherGraph).Edges))
	}
}

func (demo *odbDemo) classTree() {
	start := time.Now()
	obj, err := demo.g.GetClassChildren("/matrix/entity/pe/electric_sys", true)
	if err != nil {
		log.Fatal(err)
	}
	_, err = json.Marshal(obj)
	log.Println(time.Now().Sub(start).String())
}

func (demo *odbDemo) testCql() {
	ret, err := demo.g.RawQuery(`select * from matrix.object limit 1`)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(ret)
}

func (demo *odbDemo) testPrepare() {
	stmt := `insert into /matrix/system/depot (tags, name, version, remark) values (?, ?, ?, ?)`
	ps, err := demo.g.Prepare(stmt, &odb.QueryMeta{Return: odb.ReturnColMeta})
	if err != nil {
		log.Fatal(err)
	}
	values := []interface{}{
		`["SCRIPT"]`,
		"test12",
		"10",
		"null",
	}
	data, schema, err := ps.Exec(values...)
	if err != nil {
		log.Fatal(err)
	}
	log.Println("data:", data)
	log.Println("schema:", schema)
}

func (demo *odbDemo) testMql() {
	data, meta, err := demo.g.Query("select id, name, biz, contain from /matrix/devops/event limit 10", &odb.QueryMeta{Return: odb.ReturnColMeta})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Meta:")
	mb, err := json.MarshalIndent(meta, "", "    ")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(mb))

	fmt.Println("Data:")
	b, err := json.MarshalIndent(data, "", "    ")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(b))
}

func (demo *odbDemo) testBucket() {
	//mql := `select id, host, bk2["iparam1", "iparam2"].time('2020-05-23 00:00:00', '2020-05-23 23:59:59') from testbucket4`
	mql := `SELECT id, bk2 FROM /matrix/testbucket7/subbk`
	data, meta, err := demo.g.Query(mql)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Meta:")
	mb, _ := json.MarshalIndent(meta, "", "    ")
	fmt.Println("Data:")
	db, _ := json.MarshalIndent(data, "", "    ")
	fmt.Println(string(mb))
	fmt.Println(string(db))
}

func main() {
	log.SetFlags(log.LstdFlags | log.Lshortfile)

	g, err := odb.New(&odb.Option{Cache: odb.CacheAll, DisableInitialHostLookup: true}) // For aliyun
	//g, err := odb.New(&odb.Option{Cache:odb.CacheAll})
	if err != nil {
		log.Fatal(err)
	}
	demo := &odbDemo{g: g}
	//demo.testMql()
	//demo.testPrepare()
	//demo.testCql()
	demo.graph()
	//demo.classTree()
	//demo.testStreamingSearch()
	//demo.testBucket()
	//demo.testIndex()
}

/*
[
  {
    "graph": {
      "nodes": [
        {
          "_icon": "linux",
          "class": "/matrix/entity/linux",
          "id": "linux:h2"
        },
        {
          "_icon": "cassandra",
          "class": "/matrix/entity/cassandra",
          "id": "cassandra:c1"
        },
        {
          "_icon": "biz",
          "class": "/matrix/entity/biz",
          "id": "biz:b1"
        },
        {
          "_icon": "linux",
          "class": "/matrix/entity/linux",
          "id": "linux:h1"
        }
      ],
      "edges": [
        {
          "class": "contain",
          "id": "biz:b1-linux:h1",
          "source": "biz:b1",
          "target": "linux:h1"
        },
        {
          "class": "contain",
          "id": "biz:b1-linux:h2",
          "source": "biz:b1",
          "target": "linux:h2"
        },
        {
          "class": "contain",
          "id": "linux:h1-cassandra:c1",
          "source": "linux:h1",
          "target": "cassandra:c1"
        }
      ],
      "paths": null,
      "pathtags": null
    }
  }
]
*/