package main

import (
	"database/sql"
	"flag"
	"fmt"
	"log"
	"regexp"
	"strconv"

	"github.com/jackc/pgx"
	"github.com/jackc/pgx/stdlib"

	"gemma.intevation.de/gemma/pkg/soap/ifbn"
)

const insertSQL = `INSERT INTO waterway.bottlenecks (
	bottleneck_id,
	fk_g_fid,
	objnam,
	nobjnm,
	stretch,
	area,
	rb,
	lb,
	responsible_country,
	revisiting_time,
	limiting,
	date_info,
	source_organization
) VALUES(
	$1,
	isrs_fromText($2),
	$3,
	$4,
	isrsrange(isrs_fromText($5), isrs_fromText($6)),
	ST_MakePolygon(ST_GeomFromText('LINESTRING(0 0,1 0,1 1,0 0)', 4326))::Geography,
	$7,
	$8,
	$9,
	$10,
	$11,
	$12,
	$13
) ON CONFLICT (bottleneck_id) DO NOTHING`

var (
	url        = flag.String("url", "", "the IFBN service")
	insecure   = flag.Bool("insecure", false, "skip SSL verification")
	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)
}

var rblbRe = regexp.MustCompile(`(..)_(..)`)

func splitRBLB(s string) (string, string) {
	m := rblbRe.FindStringSubmatch(s)
	if len(m) == 0 {
		return "", ""
	}
	return m[1], m[2]
}

func revisitingTime(s string) int {
	v, err := strconv.Atoi(s)
	if err != nil {
		v = 0
	}
	return v
}

func main() {

	flag.Parse()

	client := ifbn.NewIBottleneckService(*url, *insecure, nil)

	req := &ifbn.Export_bn_by_isrs{}

	resp, err := client.Export_bn_by_isrs(req)
	if err != nil {
		log.Fatalf("error: %v\n", err)
	}

	if resp.Export_bn_by_isrsResult == nil {
		return
	}
	bns := resp.Export_bn_by_isrsResult.BottleNeckType

	err = run(func(db *sql.DB) error {

		stmt, err := db.Prepare(insertSQL)
		if err != nil {
			return err
		}
		defer stmt.Close()

		tx, err := db.Begin()
		if err != nil {
			return err
		}

		st := tx.Stmt(stmt)

		for i := range bns {
			bn := bns[i]
			rb, lb := splitRBLB(bn.Rb_lb)

			var limiting, country string

			if bn.Limiting_factor != nil {
				limiting = string(*bn.Limiting_factor)
			}

			if bn.Responsible_country != nil {
				country = string(*bn.Responsible_country)
			}

			fmt.Printf("%s '%s' %s %s\n", bn.Fk_g_fid, bn.OBJNAM, bn.From_ISRS, bn.To_ISRS)

			if _, err := st.Exec(
				bn.Bottleneck_id,
				bn.Fk_g_fid,
				bn.OBJNAM,
				bn.NOBJNM,
				bn.From_ISRS, bn.To_ISRS,
				rb,
				lb,
				country,
				revisitingTime(bn.Revisiting_time),
				limiting,
				bn.Date_Info,
				bn.Source,
			); err != nil {
				tx.Rollback()
				return err
			}
		}

		return tx.Commit()
	})

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