package bbgo

import (
	"bytes"
	"encoding/json"
	"reflect"

	"github.com/pkg/errors"

	"github.com/c9s/bbgo/pkg/dynamic"
)

type ExitMethodSet []ExitMethod

func (s *ExitMethodSet) SetAndSubscribe(session *ExchangeSession, parent interface{}) {
	for i := range *s {
		m := (*s)[i]

		// manually inherit configuration from strategy
		m.Inherit(parent)
		m.Subscribe(session)
	}
}

func (s *ExitMethodSet) Bind(session *ExchangeSession, orderExecutor *GeneralOrderExecutor) {
	for _, method := range *s {
		method.Bind(session, orderExecutor)
	}
}

type ExitMethod struct {
	RoiStopLoss               *RoiStopLoss               `json:"roiStopLoss"`
	ProtectiveStopLoss        *ProtectiveStopLoss        `json:"protectiveStopLoss"`
	RoiTakeProfit             *RoiTakeProfit             `json:"roiTakeProfit"`
	LowerShadowTakeProfit     *LowerShadowTakeProfit     `json:"lowerShadowTakeProfit"`
	CumulatedVolumeTakeProfit *CumulatedVolumeTakeProfit `json:"cumulatedVolumeTakeProfit"`
	TrailingStop              *TrailingStop2             `json:"trailingStop"`
}

func (e ExitMethod) String() string {
	var buf bytes.Buffer
	if e.RoiStopLoss != nil {
		b, _ := json.Marshal(e.RoiStopLoss)
		buf.WriteString("roiStopLoss: " + string(b) + ", ")
	}
	if e.ProtectiveStopLoss != nil {
		b, _ := json.Marshal(e.ProtectiveStopLoss)
		buf.WriteString("protectiveStopLoss: " + string(b) + ", ")
	}
	if e.RoiTakeProfit != nil {
		b, _ := json.Marshal(e.RoiTakeProfit)
		buf.WriteString("rioTakeProft: " + string(b) + ", ")
	}
	if e.LowerShadowTakeProfit != nil {
		b, _ := json.Marshal(e.LowerShadowTakeProfit)
		buf.WriteString("lowerShadowTakeProft: " + string(b) + ", ")
	}
	if e.CumulatedVolumeTakeProfit != nil {
		b, _ := json.Marshal(e.CumulatedVolumeTakeProfit)
		buf.WriteString("cumulatedVolumeTakeProfit: " + string(b) + ", ")
	}
	if e.TrailingStop != nil {
		b, _ := json.Marshal(e.TrailingStop)
		buf.WriteString("trailingStop: " + string(b) + ", ")
	}
	return buf.String()
}

// Inherit is used for inheriting properties from the given strategy struct
// for example, some exit method requires the default interval and symbol name from the strategy param object
func (m *ExitMethod) Inherit(parent interface{}) {
	// we need to pass some information from the strategy configuration to the exit methods, like symbol, interval and window
	rt := reflect.TypeOf(m).Elem()
	rv := reflect.ValueOf(m).Elem()
	for j := 0; j < rv.NumField(); j++ {
		if !rt.Field(j).IsExported() {
			continue
		}

		fieldValue := rv.Field(j)
		if fieldValue.Kind() == reflect.Ptr && fieldValue.IsNil() {
			continue
		}

		dynamic.InheritStructValues(fieldValue.Interface(), parent)
	}
}

func (m *ExitMethod) Subscribe(session *ExchangeSession) {
	if err := dynamic.CallStructFieldsMethod(m, "Subscribe", session); err != nil {
		panic(errors.Wrap(err, "dynamic Subscribe call failed"))
	}
}

func (m *ExitMethod) Bind(session *ExchangeSession, orderExecutor *GeneralOrderExecutor) {
	if m.ProtectiveStopLoss != nil {
		m.ProtectiveStopLoss.Bind(session, orderExecutor)
	}

	if m.RoiStopLoss != nil {
		m.RoiStopLoss.Bind(session, orderExecutor)
	}

	if m.RoiTakeProfit != nil {
		m.RoiTakeProfit.Bind(session, orderExecutor)
	}

	if m.LowerShadowTakeProfit != nil {
		m.LowerShadowTakeProfit.Bind(session, orderExecutor)
	}

	if m.CumulatedVolumeTakeProfit != nil {
		m.CumulatedVolumeTakeProfit.Bind(session, orderExecutor)
	}

	if m.TrailingStop != nil {
		m.TrailingStop.Bind(session, orderExecutor)
	}
}