// ------------------------------------------------------------------------
//   Project active2
//   Active Thing (activething.com) git.activething.com/go
//
//   File name  active.go
//   Created by DEV
//   Modified   23/03/2024
//
//   Copyright 2024 activething.com 
// ------------------------------------------------------------------------
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ------------------------------------------------------------------------


package errs

import (
	"errs/erfmt"
	"errs/erfmt/ftext"
	"errs/stack"
	"fmt"
	"reflect"
	"sync"
)

const (

	CodePanicError 				string = "panic"
	CodeMultiError 				string = "multi"


	CodeParamError    			string = "param"
	CodeParamNilError 			string = "param-nil"
	CodeParamOutOfRangeError	string = "param-out-of-range"
)

var (
	G = struct {

		Formatter erfmt.Formatter

		ErrParam           ErrCode
		ErrParamNil        ErrCode
		ErrParamOutOfRange ErrCode

	}{

		ErrParam			: ErrCode(CodeParamError),
		ErrParamNil			: ErrCode(CodeParamNilError),
		ErrParamOutOfRange	: ErrCode(CodeParamOutOfRangeError),

		Formatter 			: ftext.DefaultFormatter(),
	}

	g = struct {
		mux 				sync.RWMutex
		stackTraceRType 	reflect.Type
	}{
		stackTraceRType 	: reflect.TypeOf(stack.Trace(nil)),
	}
)





func ToErr (err any) error {
	if err == nil {
		return nil
	}
	switch e := err.(type) {
	case error  : return e
	//case []error: return MakeErrGroup(e...)
	default     : return fmt.Errorf("%v",err)
	}
}


func ToFormat (err error, formatter erfmt.Formatter) string {
	if formatter != nil {
		return string(formatter.Format(err))
	}
	return string(G.Formatter.Format(err))
}


func ToString (err error) string {
	if err == nil {
		return ""
	}
	if st,is := err.(interface { String() string }); is {
		return st.String()
	}
	return err.Error()
}


func PanicRecoveredError (rec any) error {
	if rec == nil {
		return nil
	}
	return *NewErrPanic(ToErr(rec))
}


func Unwrap(err error) error {
	if err == nil {
		return nil
	}
	if cs,is := err.(Unwrapper); is {


		return cs.Unwrap()
	}
	return nil
}


func UnwrapCause(err error) error {
	e := err
	for e != nil {
		cs,is := e.(Causer)
		if is {
			return cs.Cause()
		}
		e = Unwrap(e)
	}
	return nil
}


func UnwrapCauses (err error) []error {
	if err == nil {
		return nil
	}
	if al,is := err.(Causers); is {
		return al.Causes()
	}
	var l ErrorList
	e := err
	for e!= nil {
		l = append(l,e)
		e = Unwrap(e)
	}
	return l
}


func UnwrapList(err error) ErrorList {
	if err == nil {
		return nil
	}
	if al,is := err.(UnwrapperList); is {
		return al.Unwrap()
	}
	var l ErrorList
	e := err
	for e!= nil {
		l = append(l,e)
		e = Unwrap(e)
	}
	return l
}


func UnwrapTrace(err error) stack.Trace {
	return stack.UnwrapTrace(err,false) }



func Wrap (err, cause error) error {
	if err == nil {
		return cause
	}
	if cause == nil {
		return err
	}
	return *NewErrCause(err, cause)
}


func WrapWithCause(err error, cause error) error {
	if err == nil && cause == nil {
		return nil
	}
	if err == nil {
		return cause
	}
	if cause == nil {
		return err
	}
	return *NewErrCause(err,cause)
}


func WrapWithInfo (err error, options ...ErrInfoFnc) error {
	if err == nil {
		return nil
	}
	return *NewErrInfo(err,options...)
}


func WrapWithTrace(err error, offset int) error {
	if err == nil {
		return nil
	}
	return *NewErrTrace(err,offset)
}