package main

import (
	"bufio"
	"errors"
	"fmt"
	"math"
	"os"
	"strconv"
	"strings"
)

const NORMAL90CONFIDENCE = 1.6448536269514727

// Actually, I should look up how do do a) enums in go, b) union types
type Lognormal struct {
	low  float64
	high float64
}

type Dist struct {
	Type      string
	Lognormal Lognormal
	Samples   []float64
}

// Parse line into Distribution
func parseLineErr(err_msg string) (string, Dist, error) {
	return "", Dist{}, errors.New(err_msg)
}
func parseLine(line string) (string, Dist, error) {

	words := strings.Split(strings.TrimSpace(line), " ")
	op := ""
	var dist Dist

	switch words[0] {
	case "*":
		op = "*"
		words = words[1:]
	case "/":
		op = "/"
		words = words[1:]
	case "+":
		return parseLineErr("+ operation not implemented yet")
	case "-":
		return parseLineErr("- operation not implemented yet")
	default:
		op = "*" // later, change the below to
	}

	switch len(words) {
	case 0:
		return parseLineErr("Can't operate on nothing")
	case 1:
		single_float, err1 := strconv.ParseFloat(words[0], 64)
		if err1 != nil {
			fmt.Println("Trying to operate on a scalar, but scalar is not a float")
		}
		dist = Dist{Type: "Lognormal", Lognormal: Lognormal{low: single_float, high: single_float}, Samples: nil}
	case 2:
		new_low, err1 := strconv.ParseFloat(words[0], 64)
		new_high, err2 := strconv.ParseFloat(words[1], 64)
		if err1 != nil || err2 != nil {
			return parseLineErr("Trying to operate by a distribution, but distribution is not specified as two floats")
		}
		dist = Dist{Type: "Lognormal", Lognormal: Lognormal{low: new_low, high: new_high}, Samples: nil}
	default:
		return parseLineErr("Other input methods not implemented yet")
	}
	return op, dist, nil

}

// Join distributions
// Multiply lognormals

func logBoundsToLogParams(low float64, high float64) (float64, float64) {
	loglow := math.Log(low)
	loghigh := math.Log(high)
	logmean := (loghigh + loglow) / 2.0
	logstd := (loghigh - loglow) / (2.0 * NORMAL90CONFIDENCE)
	return logmean, logstd
}
func logParamsToLogBounds(logmean float64, logstd float64) (float64, float64) {
	h := logstd * NORMAL90CONFIDENCE
	loglow := logmean - h
	loghigh := logmean + h
	return math.Exp(loglow), math.Exp(loghigh)
}
func multiplyLogParams(logmean1 float64, logstd1 float64, logmean2 float64, logstd2 float64) (float64, float64) {
	return logmean1 + logmean2, math.Sqrt(logstd1*logstd1 + logstd2*logstd2)
}
func multiplyLogBounds(old_low, old_high, new_low, new_high float64) (float64, float64) {
	logmean_old, logstd_old := logBoundsToLogParams(old_low, old_high)
	logmean_new, logstd_new := logBoundsToLogParams(new_low, new_high)

	logmean_product, logstd_product := multiplyLogParams(logmean_old, logstd_old, logmean_new, logstd_new)

	return logParamsToLogBounds(logmean_product, logstd_product)
}

func joinDists(old_dist Dist, new_dist Dist, op string) (Dist, error) {
	switch {
	case old_dist.Type == "Lognormal" && new_dist.Type == "Lognormal" && op == "*":
		low, high := multiplyLogBounds(old_dist.Lognormal.low, old_dist.Lognormal.high, new_dist.Lognormal.low, new_dist.Lognormal.high)
		return Dist{Type: "Lognormal", Lognormal: Lognormal{low: low, high: high}, Samples: nil}, nil
	default:
		fmt.Printf("For now, can't do anything besides multiplying lognormals")
	}
	return old_dist, errors.New("Error blah blah")
}

/* Main event loop */
func main() {
	reader := bufio.NewReader(os.Stdin)
	old_dist := Dist{Type: "Lognormal", Lognormal: Lognormal{low: 1, high: 1}, Samples: nil} // Could also just be a scalar
	fmt.Printf("Hello world")

EventForLoop:
	for {
		input, _ := reader.ReadString('\n')
		if strings.TrimSpace(input) == "" {
			continue EventForLoop
		}

		op, new_dist, err := parseLine(input)
		if err != nil {

		}
		joint_dist, err := joinDists(old_dist, new_dist, op)
		if err != nil {

		}
		old_dist = joint_dist
	}
}