package kresult

import (
	"fmt"
	"testing"
)

type tester struct {
	t *testing.T
}

func TestResult(t *testing.T) {
	sf := &tester{
		t: t,
	}
	sf.create()
}

// Создаёт новый Result
func (sf *tester) create() {
	sf.t.Log("create")
	sf.createOkBad1()
	sf.createOkGood1()
	sf.createOkGood2()
	sf.createErrBad1()
	sf.createErrGood1()
}

func (sf *tester) createErrGood1() {
	sf.t.Log("createErrGood1")
	defer func() {
		if _panic := recover(); _panic != nil {
			sf.t.Fatalf("createErrGood1(): panic=%v", _panic)
		}
	}()
	err := fmt.Errorf("test err")
	res := NewErr(err)
	if res == nil {
		sf.t.Fatalf("createErrGood1(): res==nil")
	}
	if res.IsOk() {
		sf.t.Fatalf("createErrGood1(): is ok")
	}
	if !res.IsErr() {
		sf.t.Fatalf("createErrGood1(): not err")
	}
	if val := res.UnwrapOr("test2"); val != "test2" {
		sf.t.Fatalf("createErrGood1(): val bad")
	}
	if val := res.UnwrapOr("test1"); val != "test1" {
		sf.t.Fatalf("createErrGood1(): val bad")
	}
	if val := res.UnwrapOrFn(sf.fnWrap2); val != "test5" {
		sf.t.Fatalf("createErrGood1(): val bad")
	}
	if err := res.Error(); err == nil {
		sf.t.Fatalf("createErrGood1(): err == nil")
	}
	sf.unwrapErr(res)
	sf.hassert(res)
	sf.assert(res)
}

func (sf *tester) assert(res *Result[any]) {
	sf.t.Log("assert")
	defer func() {
		if _panic := recover(); _panic == nil {
			sf.t.Fatalf("assert(): panic==nil")
		}
	}()
	res.Hassert("test assert")
}

func (sf *tester) hassert(res *Result[any]) {
	sf.t.Log("hassert")
	defer func() {
		if _panic := recover(); _panic == nil {
			sf.t.Fatalf("hassert(): panic==nil")
		}
	}()
	res.Hassert("test hassert")
}

func (sf *tester) unwrapErr(res *Result[any]) {
	sf.t.Log("unwrapErr")
	defer func() {
		if _panic := recover(); _panic == nil {
			sf.t.Fatalf("unwrapErr(): panic==nil")
		}
	}()
	_ = res.Unwrap()
}

// Нет ошибки
func (sf *tester) createErrBad1() {
	sf.t.Log("createErrBad1")
	defer func() {
		if _panic := recover(); _panic == nil {
			sf.t.Fatalf("createErrBad1(): panic==nil")
		}
	}()
	var err error
	_ = NewErr(err)
}

func (sf *tester) createOkGood2() {
	sf.t.Log("createOkGood2")
	defer func() {
		if _panic := recover(); _panic != nil {
			sf.t.Fatalf("createOkGood2(): panic=%v", _panic)
		}
	}()
	str := "test val"
	res := NewOk(str)
	if res == nil {
		sf.t.Fatalf("createOkGood1(): res==nil")
	}
	if !res.IsOk() {
		sf.t.Fatalf("createOkGood1(): not ok")
	}
	if res.IsErr() {
		sf.t.Fatalf("createOkGood1(): is err")
	}
	if val := res.Unwrap(); val != "test val" {
		sf.t.Fatalf("createOkGood1(): val bad")
	}
	if val := res.UnwrapOr("test1"); val != "test val" {
		sf.t.Fatalf("createOkGood1(): val bad")
	}
	if val := res.UnwrapOr("test1"); val != "test val" {
		sf.t.Fatalf("createOkGood1(): val bad")
	}
	if val := res.UnwrapOrFn(sf.fnWrap); val != "test val" {
		sf.t.Fatalf("createOkGood1(): val bad")
	}
	if err := res.Error(); err != nil {
		sf.t.Fatalf("createOkGood1(): err !=nil")
	}
	res.Hassert("test")
	res.Assert("test")
}

// Функция высшего порядка для замещения ошибки
func (sf *tester) fnWrap2() any {
	return "test5"
}

// Функция высшего порядка для замещения ошибки
func (sf *tester) fnWrap() string {
	return "test1"
}

func (sf *tester) createOkGood1() {
	sf.t.Log("createOkGood1")
	defer func() {
		if _panic := recover(); _panic != nil {
			sf.t.Fatalf("createOkGood1(): panic=%v", _panic)
		}
	}()
	str := "test val"
	res := NewOk(&str)
	if res == nil {
		sf.t.Fatalf("createOkGood1(): res==nil")
	}
}

// Нет результата
func (sf *tester) createOkBad1() {
	sf.t.Log("createOkBad1")
	defer func() {
		if _panic := recover(); _panic == nil {
			sf.t.Fatalf("createOkBad1(): panic==nil")
		}
	}()
	var str *string
	_ = NewOk(str)
}