package main

import (
	"bufio"
	"database/sql"
	"flag"
	"fmt"
	"log"
	"os"
	"path/filepath"
	"strings"
	"time"

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

var (
	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)
}

type meta struct {
	date           time.Time
	name           string
	depthReference string
}

func substituteName(fname, name string) string {
	dir := filepath.Dir(fname)
	info := filepath.Join(dir, "INFO.txt")
	f, err := os.Open(info)
	if err != nil {
		log.Printf("warn: %v\n", err)
		return name
	}
	defer f.Close()

	s := bufio.NewScanner(f)

	for search := strings.ToLower(name); s.Scan(); {
		line := strings.TrimSpace(s.Text())
		if line == "" || strings.HasPrefix(line, "#") {
			continue
		}

		if parts := strings.SplitN(line, "=", 2); len(parts) == 2 &&
			strings.TrimSpace(strings.ToLower(parts[0])) == search {
			return strings.TrimSpace(parts[1])
		}
	}

	if err := s.Err(); err != nil {
		log.Printf("error: %v\n", err)
	}

	return name
}

func parseFilename(fname string) (meta, error) {

	base := filepath.Base(fname)

	log.Printf("base: %s\n", base)

	idx := strings.IndexRune(base, '_')
	if idx == -1 {
		return meta{}, fmt.Errorf("%s has no date", base)
	}

	datePart := base[:idx]

	date, err := time.Parse("20060102", datePart)
	if err != nil {
		return meta{}, fmt.Errorf("error %s: %v\n", err)
	}

	rest := base[idx+1:]

	rest = rest[:len(rest)-len(filepath.Ext(rest))]

	if !strings.HasSuffix(strings.ToUpper(rest), "_WGS84") {
		return meta{}, fmt.Errorf("%s is not in WGS84", base)
	}

	rest = rest[:len(rest)-len("_WGS84")]

	if idx = strings.LastIndex(rest, "_"); idx == -1 {
		return meta{}, fmt.Errorf("%s has no depth reference", base)
	}

	depthReference := rest[idx+1:]

	rest = rest[:idx]

	if !strings.HasSuffix(strings.ToUpper(rest), "_MB") {
		return meta{}, fmt.Errorf("%s is not in WGS84", base)
	}

	name := rest[:len(rest)-len("_MB")]

	name = substituteName(fname, name)

	return meta{
		name:           name,
		depthReference: depthReference,
		date:           date,
	}, nil
}

func main() {
	flag.Parse()

	for _, fname := range flag.Args() {
		m, err := parseFilename(fname)
		if err != nil {
			log.Printf("error: %s\n", err)
			continue
		}
		fmt.Printf("%q\n", m)
	}
}