package gorqlite

/*
	this file contains some high-level Connection-oriented stuff
*/

/* *****************************************************************

   imports

 * *****************************************************************/

import "errors"
import "fmt"
import "io"
import "net"
import nurl "net/url"
import "strings"

var errClosed = errors.New("gorqlite: connection is closed")
var traceOut io.Writer

// defaults to false.  This is used in trace() to quickly
// return if tracing is off, so that we don't do a perhaps
// expensive Sprintf() call only to send it to Discard

var wantsTrace bool

/* *****************************************************************

   type: Connection

 * *****************************************************************/

/*
	The connection abstraction.	 Note that since rqlite is stateless,
	there really is no "connection".  However, this type holds
	information such as the current leader, peers, connection
	string to build URLs, etc.

	Connections are assigned a "connection ID" which is a pseudo-UUID
	for connection identification in trace output only.  This helps
	sort out what's going on if you have multiple connections going
	at once.  It's generated using a non-standards-or-anything-else-compliant
	function that uses crypto/rand to generate 16 random bytes.

	Note that the Connection objection holds info on all peers, gathered
	at time of Open() from the node specified.
*/

type Connection struct {
	cluster rqliteCluster

	/*
	  name               type                default
	*/

	username         string           //   username or ""
	password         string           //   username or ""
	consistencyLevel consistencyLevel //   WEAK
	wantsHTTPS       bool             //   false unless connection URL is https

	// variables below this line need to be initialized in Open()

	timeout       int    //   10
	hasBeenClosed bool   //   false
	ID            string //   generated in init()
}

/* *****************************************************************

   method: Connection.Close()

 * *****************************************************************/

func (conn *Connection) Close() {
	conn.hasBeenClosed = true
	trace("%s: %s", conn.ID, "closing connection")
}

/* *****************************************************************

   method: Connection.ConsistencyLevel()

 * *****************************************************************/

func (conn *Connection) ConsistencyLevel() (string, error) {
	if conn.hasBeenClosed {
		return "", errClosed
	}
	return consistencyLevelNames[conn.consistencyLevel], nil
}

/* *****************************************************************

   method: Connection.Leader()

 * *****************************************************************/

func (conn *Connection) Leader() (string, error) {
	if conn.hasBeenClosed {
		return "", errClosed
	}
	trace("%s: Leader(), calling updateClusterInfo()", conn.ID)
	err := conn.updateClusterInfo()
	if err != nil {
		trace("%s: Leader() got error from updateClusterInfo(): %s", conn.ID, err.Error())
		return "", err
	} else {
		trace("%s: Leader(), updateClusterInfo() OK", conn.ID)
	}
	return conn.cluster.leader.String(), nil
}

/* *****************************************************************

   method: Connection.Peers()

 * *****************************************************************/

func (conn *Connection) Peers() ([]string, error) {
	if conn.hasBeenClosed {
		var ans []string
		return ans, errClosed
	}
	plist := make([]string, 0)

	trace("%s: Peers(), calling updateClusterInfo()", conn.ID)
	err := conn.updateClusterInfo()
	if err != nil {
		trace("%s: Peers() got error from updateClusterInfo(): %s", conn.ID, err.Error())
		return plist, err
	} else {
		trace("%s: Peers(), updateClusterInfo() OK", conn.ID)
	}
	plist = append(plist, conn.cluster.leader.String())
	for _, p := range conn.cluster.otherPeers {
		plist = append(plist, p.String())
	}
	return plist, nil
}

/* *****************************************************************

   method: Connection.SetConsistencyLevel()

 * *****************************************************************/

func (conn *Connection) SetConsistencyLevel(levelDesired string) error {
	if conn.hasBeenClosed {
		return errClosed
	}
	_, ok := consistencyLevels[levelDesired]
	if ok {
		conn.consistencyLevel = consistencyLevels[levelDesired]
		return nil
	}
	return errors.New(fmt.Sprintf("unknown consistency level: %s", levelDesired))
}

/* *****************************************************************

   method: Connection.initConnection()

 * *****************************************************************/

/*
	initConnection takes the initial connection URL specified by
	the user, and parses it into a peer.  This peer is assumed to
	be the leader.  The next thing Open() does is updateClusterInfo()
	so the truth will be revealed soon enough.

	initConnection() does not talk to rqlite.  It only parses the
	connection URL and prepares the new connection for work.

	URL format:

		http[s]://${USER}:${PASSWORD}@${HOSTNAME}:${PORT}/db?[OPTIONS]

	Examples:

		https://mary:secret2@localhost:4001/db
		https://mary:secret2@server1.example.com:4001/db?level=none
		https://mary:secret2@server2.example.com:4001/db?level=weak
		https://mary:secret2@localhost:2265/db?level=strong

	to use default connection to localhost:4001 with no auth:
		http://
		https://

	guaranteed map fields - will be set to "" if not specified

		field name                  default if not specified

		username                    ""
		password                    ""
		hostname                    "localhost"
		port                        "4001"
		consistencyLevel            "weak"
*/

func (conn *Connection) initConnection(url string) error {

	// do some sanity checks.  You know users.

	if len(url) < 7 {
		return errors.New("url specified is impossibly short")
	}

	if strings.HasPrefix(url, "http") == false {
		return errors.New("url does not start with 'http'")
	}

	u, err := nurl.Parse(url)
	if err != nil {
		return err
	}
	trace("%s: net.url.Parse() OK", conn.ID)

	if u.Scheme == "https" {
		conn.wantsHTTPS = true
	}

	// specs say Username() is always populated even if empty

	if u.User == nil {
		conn.username = ""
		conn.password = ""
	} else {
		// guaranteed, but could be empty which is ok
		conn.username = u.User.Username()

		// not guaranteed, so test if set
		pass, isset := u.User.Password()
		if isset {
			conn.password = pass
		} else {
			conn.password = ""
		}
	}

	if u.Host == "" {
		conn.cluster.leader.hostname = "localhost"
	} else {
		conn.cluster.leader.hostname = u.Host
	}

	if u.Host == "" {
		conn.cluster.leader.hostname = "localhost"
		conn.cluster.leader.port = "4001"
	} else {
		// SplitHostPort() should only return an error if there is no host port.
		// I think.
		h, p, err := net.SplitHostPort(u.Host)
		if err != nil {
			conn.cluster.leader.hostname = u.Host
		} else {
			conn.cluster.leader.hostname = h
			conn.cluster.leader.port = p
		}
	}

	/*

		at the moment, the only allowed query is "level=" with
		the desired consistency level

	*/

	// default
	conn.consistencyLevel = cl_WEAK

	if u.RawQuery != "" {
		if u.RawQuery == "level=weak" {
			// that's ok but nothing to do
		} else if u.RawQuery == "level=strong" {
			conn.consistencyLevel = cl_STRONG
		} else if u.RawQuery == "level=none" { // the fools!
			conn.consistencyLevel = cl_NONE
		} else {
			return errors.New("don't know what to do with this query: " + u.RawQuery)
		}
	}

	trace("%s: parseDefaultPeer() is done:", conn.ID)
	if conn.wantsHTTPS == true {
		trace("%s:    %s -> %s", conn.ID, "wants https?", "yes")
	} else {
		trace("%s:    %s -> %s", conn.ID, "wants https?", "no")
	}
	trace("%s:    %s -> %s", conn.ID, "username", conn.username)
	trace("%s:    %s -> %s", conn.ID, "password", conn.password)
	trace("%s:    %s -> %s", conn.ID, "hostname", conn.cluster.leader.hostname)
	trace("%s:    %s -> %s", conn.ID, "port", conn.cluster.leader.port)
	trace("%s:    %s -> %s", conn.ID, "consistencyLevel", consistencyLevelNames[conn.consistencyLevel])

	conn.cluster.conn = conn

	return nil
}