package main

import (
	"database/sql"
	"flag"
	"log"
	"math"
	"os"
	"time"

	"github.com/golang/snappy"
	"github.com/jackc/pgx"
	"github.com/jackc/pgx/stdlib"
)

var (
	bottleneck = flag.String("bottleneck", "", "bottleneck id")
	date       = flag.String("date", "", "date info")
	file       = flag.String("file", "", "save to file")

	utm = flag.Bool("utm", false, "fetch in matchin UTM zone")

	dbhost     = flag.String("dbhost", "localhost", "database host")
	dbport     = flag.Uint("dbport", 5432, "database port")
	dbname     = flag.String("dbname", "gemma", "database user")
	dbuser     = flag.String("dbuser", "scott", "database user")
	dbpassword = flag.String("dbpw", "tiger", "database password")
	dbssl      = flag.String("dbssl", "prefer", "database SSL mode")
)

func run(fn func(*sql.DB) error) error {

	// To ease SSL config ride a bit on parsing.
	cc, err := pgx.ParseConnectionString("sslmode=" + *dbssl)
	if err != nil {
		return err
	}

	// Do the rest manually to allow whitespace in user/password.
	cc.Host = *dbhost
	cc.Port = uint16(*dbport)
	cc.User = *dbuser
	cc.Password = *dbpassword
	cc.Database = *dbname

	db := stdlib.OpenDB(cc)
	defer db.Close()

	return fn(db)
}

const (
	tinSQL = `
SELECT ST_AsBinary(ST_DelaunayTriangles(point_cloud::geometry, 0, 2))
FROM waterway.sounding_results
WHERE bottleneck_id = $1 AND date_info = $2
`
	tinUTMSQL = `
SELECT ST_AsBinary(
  ST_DelaunayTriangles(
	  ST_Transform(point_cloud::geometry, $3::int), 0, 2))
FROM waterway.sounding_results
WHERE bottleneck_id = $1 AND date_info = $2
`
	centroidSQL = `
SELECT ST_X(ST_Centroid(point_cloud::geometry)), ST_Y(ST_Centroid(point_cloud::geometry))
FROM waterway.sounding_results
WHERE bottleneck_id = $1 AND date_info = $2
`
)

func utmZone(x, y float64) int {
	var pref int
	if y > 0 {
		pref = 32600
	} else {
		pref = 32700
	}
	zone := int(math.Floor((x+180)/6)) + 1
	return zone + pref
}

func main() {
	flag.Parse()

	if *bottleneck == "" || *date == "" {
		log.Fatalln("missing bottleneck or date option.")
	}

	dateInfo, err := time.Parse("2006-01-02", *date)
	if err != nil {
		log.Fatalf("error: %v\n", err)
	}

	var t tin

	if err := run(func(db *sql.DB) error {
		var utmZ int

		if *utm {
			var cx, cy float64
			err := db.QueryRow(centroidSQL, *bottleneck, dateInfo).Scan(&cx, &cy)
			switch {
			case err == sql.ErrNoRows:
				return nil
			case err != nil:
				return err
			}
			log.Printf("lat/lon: [%f, %f]\n", cx, cy)
			utmZ = utmZone(cx, cy)
			log.Printf("UTM zone: %d\n", utmZ)
		}

		start := time.Now()
		var err error
		if *utm {
			err = db.QueryRow(tinUTMSQL, *bottleneck, dateInfo, utmZ).Scan(&t)
		} else {
			err = db.QueryRow(tinSQL, *bottleneck, dateInfo).Scan(&t)
		}
		switch {
		case err == sql.ErrNoRows:
			return nil
		case err != nil:
			return err
		}
		log.Printf("query took: %s\n", time.Since(start))

		if *utm {
			t.epsg = uint32(utmZ)
		}

		return nil
	}); err != nil {
		log.Fatalf("error: %v\n", err)
	}

	tb := &treeBuilder{t: &t}
	tb.build()

	if *file != "" {
		f, err := os.Create(*file)
		if err != nil {
			log.Printf("error: %v\n", err)
		}
		out := snappy.NewBufferedWriter(f)
		if err := t.Serialize(out); err != nil {
			f.Close()
			log.Fatalf("error: %v\n", err)
		}
		if err := tb.Serialize(out); err != nil {
			f.Close()
			log.Fatalf("error: %v\n", err)
		}
		if err := out.Flush(); err != nil {
			f.Close()
			log.Fatalf("error: %v\n", err)
		}
		if err := f.Close(); err != nil {
			log.Fatalf("error: %v\n", err)
		}
	}
}