package core

import (
	"context"
	fmt "fmt"
	"reflect"
	"sync"

	"v2ray.com/core/common"
	"v2ray.com/core/common/serial"
	"v2ray.com/core/features"
	"v2ray.com/core/features/dns"
	"v2ray.com/core/features/inbound"
	"v2ray.com/core/features/outbound"
	"v2ray.com/core/features/policy"
	"v2ray.com/core/features/routing"
)

// Server is an instance of V2Ray. At any time, there must be at most one Server instance running.
type Server interface {
	common.Runnable
}

// ServerType returns the type of the server.
func ServerType() interface{} {
	return (*Instance)(nil)
}

type resolution struct {
	deps     []interface{}
	callback func([]features.Feature)
}

func getFeature(allFeatures []features.Feature, t interface{}) features.Feature {
	for _, f := range allFeatures {
		if f.Type() == t {
			return f
		}
	}
	return nil
}

func (r *resolution) resolve(allFeatures []features.Feature) bool {
	var fs []features.Feature
	for _, d := range r.deps {
		f := getFeature(allFeatures, d)
		if f == nil {
			return false
		}
		fs = append(fs, f)
	}

	r.callback(fs)
	return true
}

// Instance combines all functionalities in V2Ray.
type Instance struct {
	access             sync.Mutex
	features           []features.Feature
	featureResolutions []resolution
	running            bool
}

// New returns a new V2Ray instance based on given configuration.
// The instance is not started at this point.
// To ensure V2Ray instance works properly, the config must contain one Dispatcher, one InboundHandlerManager and one OutboundHandlerManager. Other features are optional.
func New(config *Config) (*Instance, error) {
	var server = &Instance{}

	if config.Transport != nil {
		features.PrintDeprecatedFeatureWarning("global transport settings")
	}
	if err := config.Transport.Apply(); err != nil {
		return nil, err
	}

	for _, appSettings := range config.App {
		settings, err := appSettings.GetInstance()
		if err != nil {
			return nil, err
		}
		obj, err := CreateObject(server, settings)
		if err != nil {
			return nil, err
		}
		if feature, ok := obj.(features.Feature); ok {
			server.AddFeature(feature)
		}
	}

	if server.GetFeature(dns.ClientType()) == nil {
		server.AddFeature(dns.LocalClient{})
	}

	if server.GetFeature(policy.ManagerType()) == nil {
		server.AddFeature(policy.DefaultManager{})
	}

	if server.GetFeature(routing.RouterType()) == nil {
		server.AddFeature(routing.DefaultRouter{})
	}

	server.AddFeature(&Instance{})

	if server.featureResolutions != nil {
		fmt.Println("registered")
		for _, d := range server.features {
			fmt.Println(reflect.TypeOf(d.Type()))
		}
		for idx, r := range server.featureResolutions {
			fmt.Println(idx)
			for _, d := range r.deps {
				fmt.Println(reflect.TypeOf(d))
			}
		}
		return nil, newError("not all dependency are resolved.")
	}

	if len(config.Inbound) > 0 {
		inboundManager := server.GetFeature(inbound.ManagerType()).(inbound.Manager)
		for _, inboundConfig := range config.Inbound {
			rawHandler, err := CreateObject(server, inboundConfig)
			if err != nil {
				return nil, err
			}
			handler, ok := rawHandler.(inbound.Handler)
			if !ok {
				return nil, newError("not an InboundHandler")
			}
			if err := inboundManager.AddHandler(context.Background(), handler); err != nil {
				return nil, err
			}
		}
	}

	if len(config.Outbound) > 0 {
		outboundManager := server.GetFeature(outbound.ManagerType()).(outbound.Manager)
		for _, outboundConfig := range config.Outbound {
			rawHandler, err := CreateObject(server, outboundConfig)
			if err != nil {
				return nil, err
			}
			handler, ok := rawHandler.(outbound.Handler)
			if !ok {
				return nil, newError("not an OutboundHandler")
			}
			if err := outboundManager.AddHandler(context.Background(), handler); err != nil {
				return nil, err
			}
		}
	}

	return server, nil
}

// Type implements common.HasType.
func (s *Instance) Type() interface{} {
	return ServerType()
}

// Close shutdown the V2Ray instance.
func (s *Instance) Close() error {
	s.access.Lock()
	defer s.access.Unlock()

	s.running = false

	var errors []interface{}
	for _, f := range s.features {
		if err := f.Close(); err != nil {
			errors = append(errors, err)
		}
	}
	if len(errors) > 0 {
		return newError("failed to close all features").Base(newError(serial.Concat(errors...)))
	}

	return nil
}

// RequireFeatures registers a callback, which will be called when all dependent features are registered.
func (s *Instance) RequireFeatures(featureTypes []interface{}, callback func([]features.Feature)) {
	r := resolution{
		deps:     featureTypes,
		callback: callback,
	}
	if r.resolve(s.features) {
		return
	}
	s.featureResolutions = append(s.featureResolutions, r)
}

// AddFeature registers a feature into current Instance.
func (s *Instance) AddFeature(feature features.Feature) {
	s.features = append(s.features, feature)

	if s.running {
		if err := feature.Start(); err != nil {
			newError("failed to start feature").Base(err).WriteToLog()
		}
		return
	}

	if s.featureResolutions == nil {
		return
	}

	var pendingResolutions []resolution
	for _, r := range s.featureResolutions {
		if !r.resolve(s.features) {
			pendingResolutions = append(pendingResolutions, r)
		}
	}
	if len(pendingResolutions) == 0 {
		s.featureResolutions = nil
	} else if len(pendingResolutions) < len(s.featureResolutions) {
		s.featureResolutions = pendingResolutions
	}
}

// GetFeature returns a feature of the given type, or nil if such feature is not registered.
func (s *Instance) GetFeature(featureType interface{}) features.Feature {
	return getFeature(s.features, featureType)
}

// Start starts the V2Ray instance, including all registered features. When Start returns error, the state of the instance is unknown.
// A V2Ray instance can be started only once. Upon closing, the instance is not guaranteed to start again.
func (s *Instance) Start() error {
	s.access.Lock()
	defer s.access.Unlock()

	s.running = true
	for _, f := range s.features {
		if err := f.Start(); err != nil {
			return err
		}
	}

	newError("V2Ray ", Version(), " started").AtWarning().WriteToLog()

	return nil
}