package result_test

import (
	"fmt"
	"strconv"

	"gitea.djmil.dev/go/template/pkg/result"
)

// parseHost is an example of a simple utility function, that validates a hostname.
func parseHost(s string) result.Expect[string] {
	if s == "" {
		return result.Errf[string]("host must not be empty")
	}
	return result.Ok(s)
}

// parsePort wraps strconv.Atoi so callers can use the happy-path style.
func parsePort(s string) result.Expect[int] {
	port := result.Of(strconv.Atoi(s))
	if port.Err() != nil {
		return port
	}
	if port.Value() < 1 || port.Value() > 65535 {
		return result.Errf[int]("%d out of range", port.Value())
	}
	return port
}

// Example_errCheck shows checking the error without panicking — useful at the
// outermost boundary where you want a normal error return.
func Example_errCheck() {
	r := parsePort("not-a-number")
	if r.Err() != nil {
		fmt.Println("parsePort failed:", r.Err())
	}
	// Output:
	// parsePort failed: strconv.Atoi: parsing "not-a-number": invalid syntax
}

// Example_happyPath shows the basic happy-path pattern: call Expect at each
// step; if anything fails the panic unwinds to the nearest Catch.
func Example_happyPath() {
	host := parseHost("localhost").Expect("read host")
	fmt.Println(host)
	// Output:
	// localhost
}

// Example_catch shows the failure path: when Expect exits the goroutine,
// defer Catch at the entry point converts it into a normal error return.
func Example_catch() {
	loadHost := func() (err error) {
		defer result.Catch(&err)
		host := parseHost("").Expect("read host")
		fmt.Println(host)
		return
	}

	if err := loadHost(); err != nil {
		fmt.Println("caught:", err)
	}
	// Output:
	// caught: read host: host must not be empty
}

// getURL is an example of business logic implementation with emphasis on happy-path.
func getURL(host, port string) string {
	mHost := parseHost(host).Expect("parse host")
	mPort := parsePort(port).Expect("parse port")
	return fmt.Sprintf("http://%s:%d", mHost, mPort)
}

// Example_run shows result.Run as a lightweight synchronous boundary — a concise
// alternative to defer Catch when no named return is needed. Expect calls may be
// chained freely inside.
func Example_run() {
	err := result.Run(func() {
		url := getURL("localhost", "8080")
		fmt.Println(url)
	})

	if err != nil {
		fmt.Println("failed:", err)
	}
	// Output:
	// http://localhost:8080
}

// Example_runtimeError shows that Expectf annotates the error message with the
// formatted context, just like Expect does.
//
// NOTE: Genuine runtime panics (nil-deref, index out of bounds) are NOT collected,
// they propagate and crash the program, as they should.
func Example_runtimeError() {
	err := result.Run(func() {
		_ = parsePort("99999").Expectf("arg %d port value", 2)
	})

	if err != nil {
		fmt.Println("caught:", err)
	}
	// Output:
	// caught: arg 2 port value: 99999 out of range
}

// Example_go is like result.Run but returns a typed Expect[T] so the computed
// value can be retrieved. Any failure is collected and surfaced on that Expect.
func Example_go() {
	url := result.Go(func() string {
		return getURL("localhost", "8080")
	})

	fmt.Println(url.Expect("get url"))
	// Output:
	// http://localhost:8080
}

// Example_goError shows result.Go collecting an error when one of the chained
// Expect calls inside the goroutine fails.
func Example_goError() {
	url := result.Go(func() string {
		return getURL("localhost", "99999")
	})

	if err := url.Err(); err != nil {
		fmt.Println("failed:", err)
	}
	// Output:
	// failed: parse port: 99999 out of range
}

// Example_unwrap shows re-joining the normal Go (value, error) world at a
// boundary where both values are needed separately.
func Example_unwrap() {
	port, err := parsePort("443").Unwrap()
	if err != nil {
		fmt.Println("error:", err)
		return
	}
	fmt.Println(port)
	// Output:
	// 443
}