/*
Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
Copyright (C) ITsysCOM GmbH

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>
*/

package engine

import (
	"bytes"
	"fmt"
	"sort"
	"strings"

	"github.com/cgrates/cgrates/config"
	"github.com/cgrates/cgrates/utils"
)

// Attribute used by AttributeProfile to describe a single attribute
type Attribute struct {
	FilterIDs []string
	Path      string
	Type      string
	Value     config.RSRParsers
}

// Clone method for Attribute
func (a *Attribute) Clone() *Attribute {
	if a == nil {
		return nil
	}
	clone := &Attribute{
		Path: a.Path,
		Type: a.Type,
	}
	if a.FilterIDs != nil {
		clone.FilterIDs = make([]string, len(a.FilterIDs))
		copy(clone.FilterIDs, a.FilterIDs)
	}
	if a.Value != nil {
		clone.Value = make(config.RSRParsers, len(a.Value))
		copy(clone.Value, a.Value.Clone())
	}
	return clone
}

// AttributeProfile the profile definition for the attributes
type AttributeProfile struct {
	Tenant             string
	ID                 string
	Contexts           []string // bind this AttributeProfile to multiple contexts
	FilterIDs          []string
	ActivationInterval *utils.ActivationInterval // Activation interval
	Attributes         []*Attribute
	Blocker            bool // blocker flag to stop processing on multiple runs
	Weight             float64
}

// Clone method for AttributeProfile struct
func (ap *AttributeProfile) Clone() *AttributeProfile {
	if ap == nil {
		return nil
	}
	clone := &AttributeProfile{
		Tenant:  ap.Tenant,
		ID:      ap.ID,
		Blocker: ap.Blocker,
		Weight:  ap.Weight,
	}
	if ap.Contexts != nil {
		clone.Contexts = make([]string, len(ap.Contexts))
		copy(clone.Contexts, ap.Contexts)
	}
	if ap.FilterIDs != nil {
		clone.FilterIDs = make([]string, len(ap.FilterIDs))
		copy(clone.FilterIDs, ap.FilterIDs)
	}
	if ap.Attributes != nil {
		clone.Attributes = make([]*Attribute, len(ap.Attributes))
		for i, attr := range ap.Attributes {
			clone.Attributes[i] = attr.Clone()
		}
	}
	if ap.ActivationInterval != nil {
		clone.ActivationInterval = ap.ActivationInterval.Clone()
	}
	return clone
}

// CacheClone returns a clone of AttributeProfile used by ltcache CacheCloner
func (ap *AttributeProfile) CacheClone() any {
	return ap.Clone()
}

// AttributeProfileWithAPIOpts is used in replicatorV1 for dispatcher
type AttributeProfileWithAPIOpts struct {
	*AttributeProfile
	APIOpts map[string]any
}

func (ap *AttributeProfile) compileSubstitutes() (err error) {
	for _, attr := range ap.Attributes {
		if err = attr.Value.Compile(); err != nil {
			return
		}
	}
	return
}

// Compile is a wrapper for convenience setting up the AttributeProfile
func (ap *AttributeProfile) Compile() error {
	return ap.compileSubstitutes()
}

// TenantID returns the tenant wit the ID
func (ap *AttributeProfile) TenantID() string {
	return utils.ConcatenatedKey(ap.Tenant, ap.ID)
}

// TenantIDInline returns the id for inline
func (ap *AttributeProfile) TenantIDInline() string {
	if strings.HasPrefix(ap.ID, utils.Meta) {
		return ap.ID
	}
	return ap.TenantID()
}

// AttributeProfiles is a sortable list of Attribute profiles
type AttributeProfiles []*AttributeProfile

// Sort is part of sort interface, sort based on Weight
func (aps AttributeProfiles) Sort() {
	sort.Slice(aps, func(i, j int) bool { return aps[i].Weight > aps[j].Weight })
}

// ExternalAttribute the attribute for external profile
type ExternalAttribute struct {
	FilterIDs []string
	Path      string
	Type      string
	Value     string
}

// APIAttributeProfile used by APIs
type APIAttributeProfile struct {
	Tenant             string
	ID                 string
	Contexts           []string // bind this AttributeProfile to multiple contexts
	FilterIDs          []string
	ActivationInterval *utils.ActivationInterval // Activation interval
	Attributes         []*ExternalAttribute
	Blocker            bool // blocker flag to stop processing on multiple runs
	Weight             float64
}

// AsAttributeProfile converts the external attribute format to the actual AttributeProfile
func (ext *APIAttributeProfile) AsAttributeProfile() (attr *AttributeProfile, err error) {
	attr = new(AttributeProfile)
	if len(ext.Attributes) == 0 {
		return nil, utils.NewErrMandatoryIeMissing("Attributes")
	}
	attr.Attributes = make([]*Attribute, len(ext.Attributes))
	for i, extAttr := range ext.Attributes {
		if extAttr.Path == utils.EmptyString {
			return nil, utils.NewErrMandatoryIeMissing("Path")
		}
		if len(extAttr.Value) == 0 {
			return nil, utils.NewErrMandatoryIeMissing("Value")
		}
		attr.Attributes[i] = new(Attribute)
		if attr.Attributes[i].Value, err = config.NewRSRParsers(extAttr.Value, utils.InfieldSep); err != nil {
			return nil, err
		}
		attr.Attributes[i].Type = extAttr.Type
		attr.Attributes[i].FilterIDs = extAttr.FilterIDs
		attr.Attributes[i].Path = extAttr.Path
	}
	attr.Tenant = ext.Tenant
	attr.ID = ext.ID
	attr.Contexts = ext.Contexts
	attr.FilterIDs = ext.FilterIDs
	attr.ActivationInterval = ext.ActivationInterval
	attr.Blocker = ext.Blocker
	attr.Weight = ext.Weight
	return
}

// NewAttributeFromInline parses an inline rule into a compiled AttributeProfile
func NewAttributeFromInline(tenant, inlnRule string) (attr *AttributeProfile, err error) {
	attr = &AttributeProfile{
		Tenant:   tenant,
		ID:       inlnRule,
		Contexts: []string{utils.MetaAny},
	}
	for _, rule := range strings.Split(inlnRule, utils.InfieldSep) {
		ruleSplt := utils.SplitPath(rule, utils.InInFieldSep[0], 3)
		if len(ruleSplt) != 3 {
			return nil, fmt.Errorf("inline parse error for string: <%s>", rule)
		}
		var vals config.RSRParsers
		if vals, err = config.NewRSRParsers(ruleSplt[2], utils.ANDSep); err != nil {
			return nil, err
		}
		if len(ruleSplt[1]) == 0 {
			err = fmt.Errorf("empty path in inline AttributeProfile <%s>", inlnRule)
			return
		}
		attr.Attributes = append(attr.Attributes, &Attribute{
			Path:  ruleSplt[1],
			Type:  ruleSplt[0],
			Value: vals,
		})
	}
	return
}

func externalAttributeAPI(httpType string, dDP utils.DataProvider) (string, error) {
	urlS, err := extractUrlFromType(httpType)
	if err != nil {
		return "", err
	}
	return externalAPI(urlS, bytes.NewReader([]byte(dDP.String())))
}
