package routebuildermdl

import (
	"mime/multipart"
	"time"

	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/errormdl"
	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/servicebuildermdl"

	version "github.com/hashicorp/go-version"
	"github.com/tidwall/gjson"

	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/cachemdl"
)

var (
	restrictedServices cachemdl.FastCacheHelper
	roleBasedServices  cachemdl.FastCacheHelper
	openServices       cachemdl.FastCacheHelper
	loginService       func(*gjson.Result, servicebuildermdl.Principal) (interface{}, string, error)

	applicationVersion      *version.Version
	minimumSupportedVersion *version.Version
	isAppVersionEnabled     bool
	isStrictMode            bool
)

func init() {
	restrictedServices.Setup(10, time.Second*600, time.Second*600)
	openServices.Setup(10, time.Second*600, time.Second*600)
	roleBasedServices.Setup(10, time.Second*600, time.Second*600)
}

// ServiceCache ServiceCache object
type ServiceCache struct {
	Service         func(*gjson.Result, servicebuildermdl.Principal) (interface{}, *servicebuildermdl.AbstractBusinessLogicHolder, error)
	FormService     func(*multipart.Form, servicebuildermdl.Principal) (interface{}, *servicebuildermdl.AbstractBusinessLogicHolder, error)
	MasterService   *Runable
	IsMasterService bool
	IsFormService   bool
	ServiceType     string
}

// ServiceType -ServiceType
type ServiceType = func(*gjson.Result, servicebuildermdl.Principal) (interface{}, *servicebuildermdl.AbstractBusinessLogicHolder, error)

// // GetOpenServicePtr -GetOpenServicePtr
// func GetOpenServicePtr(serviceName string) (ServiceType, error) {
// 	intService, ok := openServices.Get(serviceName)
// 	if !ok {
// 		return nil, errormdl.Wrap("Service Not found")
// 	}
// 	serviceCache, ok := intService.(ServiceCache)
// 	if !ok {
// 		return nil, errormdl.Wrap("Service Not Ca")
// 	}
// 	return serviceCache.Service, nil
// }

// GetRestrictedServicePtr -GetRestrictedServicePtr
func GetRestrictedServicePtr(serviceName string) (ServiceType, error) {
	intService, ok := restrictedServices.Get(serviceName)
	if !ok {
		return nil, errormdl.Wrap("Service Not found")
	}
	serviceCache, ok := intService.(ServiceCache)
	if !ok {
		return nil, errormdl.Wrap("Service Not Ca")
	}
	return serviceCache.Service, nil
}

// RegisterNormalService is for transactional services
func RegisterNormalService(serviceName string, servicePtr ServiceType, isRestricted, isRoleBased bool) {
	service := ServiceCache{
		Service: servicePtr,
	}
	commonServiceRegistration(serviceName, service, isRestricted, isRoleBased)
}

// RegisterServiceInSLS is for transactional services
func RegisterServiceInSLS(serviceName string, servicePtr ServiceCache, isRestricted, isRoleBased bool) {
	// service := ServiceCache{
	// 	Service: servicePtr,
	// }
	commonServiceRegistration(serviceName, servicePtr, isRestricted, isRoleBased)
}

// RegisterFormBasedService if for multipart form based services
func RegisterFormBasedService(serviceName string, servicePtr func(*multipart.Form, servicebuildermdl.Principal) (interface{}, *servicebuildermdl.AbstractBusinessLogicHolder, error), isRestricted, isRoleBased bool) {
	service := ServiceCache{
		FormService:   servicePtr,
		IsFormService: true,
	}
	commonServiceRegistration(serviceName, service, isRestricted, isRoleBased)
}

// // RegisterMasterService is for getting master type of file
// func RegisterMasterService(serviceName string, servicePtr *servicebuildermdl.ServiceBuilder, isRestricted, isRoleBased bool) {
// 	service := ServiceCache{
// 		MasterService:   servicePtr,
// 		IsMasterService: true,
// 	}
// 	commonServiceRegistration(serviceName, service, isRestricted, isRoleBased)
// }

// RegisterMasterService is for getting master type of file
func RegisterMasterService(serviceName string, isRestricted, isRoleBased bool) *Master {
	return &Master{
		serviceName:  serviceName,
		isRoleBased:  isRoleBased,
		isRestricted: isRestricted,
	}
}

// RegisterLoginSerivce is for login service
func RegisterLoginSerivce(service func(*gjson.Result, servicebuildermdl.Principal) (interface{}, string, error)) {
	loginService = service
}

func commonServiceRegistration(serviceName string, service ServiceCache, isRestricted, isRoleBased bool) {
	if isRestricted {
		if isRoleBased {
			roleBasedServices.SetNoExpiration(serviceName, service)
		} else {
			restrictedServices.SetNoExpiration(serviceName, service)
		}
	} else {
		openServices.SetNoExpiration(serviceName, service)
	}
}

// SetAppVersion -SetAppVersion
func SetAppVersion(appVersion, minSupportedVersion string) error {

	app, err := version.NewVersion(appVersion)
	if errormdl.CheckErr(err) != nil {
		return errormdl.CheckErr(err)
	}
	min, err := version.NewVersion(minSupportedVersion)
	if errormdl.CheckErr(err) != nil {
		return errormdl.CheckErr(err)
	}

	versionValidation := min.Compare(app)
	if versionValidation == 1 {
		return errormdl.Wrap("Minimum version is more than app version")
	}
	if versionValidation == 0 {
		isStrictMode = true
	}
	applicationVersion = app
	minimumSupportedVersion = min
	isAppVersionEnabled = true
	return nil
}