/*
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 Affero 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 Affero General Public License for more details.

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

package config

import (
	"fmt"
	"slices"
	"strconv"
	"time"

	"github.com/cgrates/birpc/context"
	"github.com/cgrates/cgrates/utils"
)

const (
	SessionsAccountsDftOpt               = false
	SessionsAttributesDftOpt             = false
	SessionsCDRsDftOpt                   = false
	SessionsChargersDftOpt               = false
	SessionsResourcesDftOpt              = false
	SessionsIPsDftOpt                    = false
	SessionsRoutesDftOpt                 = false
	SessionsStatsDftOpt                  = false
	SessionsThresholdsDftOpt             = false
	SessionsInitiateDftOpt               = false
	SessionsUpdateDftOpt                 = false
	SessionsTerminateDftOpt              = false
	SessionsMessageDftOpt                = false
	SessionsAttributesDerivedReplyDftOpt = false
	SessionsBlockerErrorDftOpt           = false
	SessionsCDRsDerivedReplyDftOpt       = false
	SessionsResourcesAuthorizeDftOpt     = false
	SessionsResourcesAllocateDftOpt      = false
	SessionsResourcesReleaseDftOpt       = false
	SessionsResourcesDerivedReplyDftOpt  = false
	SessionsIPsAuthorizeDftOpt           = false
	SessionsIPsAllocateDftOpt            = false
	SessionsIPsReleaseDftOpt             = false
	SessionsRoutesDerivedReplyDftOpt     = false
	SessionsStatsDerivedReplyDftOpt      = false
	SessionsThresholdsDerivedReplyDftOpt = false
	SessionsMaxUsageDftOpt               = false
	SessionsTTLDftOpt                    = 0
	SessionsChargeableDftOpt             = true
	SessionsTTLMaxDelayDftOpt            = 0
	SessionsDebitIntervalDftOpt          = 0
)

type SessionsOpts struct {
	Accounts               []*DynamicBoolOpt
	Attributes             []*DynamicBoolOpt
	CDRs                   []*DynamicBoolOpt
	Chargers               []*DynamicBoolOpt
	Resources              []*DynamicBoolOpt
	IPs                    []*DynamicBoolOpt
	Routes                 []*DynamicBoolOpt
	Stats                  []*DynamicBoolOpt
	Thresholds             []*DynamicBoolOpt
	Authorize              []*DynamicBoolOpt
	Initiate               []*DynamicBoolOpt
	Update                 []*DynamicBoolOpt
	Terminate              []*DynamicBoolOpt
	Message                []*DynamicBoolOpt
	AttributesDerivedReply []*DynamicBoolOpt
	BlockerError           []*DynamicBoolOpt
	CDRsDerivedReply       []*DynamicBoolOpt
	ResourcesAuthorize     []*DynamicBoolOpt
	ResourcesAllocate      []*DynamicBoolOpt
	ResourcesRelease       []*DynamicBoolOpt
	ResourcesDerivedReply  []*DynamicBoolOpt
	ResourcesUsageID       []*DynamicStringOpt
	ResourcesUnits         []*DynamicIntOpt
	IPsAuthorize           []*DynamicBoolOpt
	IPsAllocate            []*DynamicBoolOpt
	IPsRelease             []*DynamicBoolOpt
	RoutesDerivedReply     []*DynamicBoolOpt
	StatsDerivedReply      []*DynamicBoolOpt
	ThresholdsDerivedReply []*DynamicBoolOpt
	MaxUsage               []*DynamicBoolOpt
	ForceUsage             []*DynamicBoolOpt
	TTL                    []*DynamicDurationOpt
	Chargeable             []*DynamicBoolOpt
	TTLLastUsage           []*DynamicDurationPointerOpt
	TTLLastUsed            []*DynamicDurationPointerOpt
	DebitInterval          []*DynamicDurationOpt
	TTLMaxDelay            []*DynamicDurationOpt
	TTLUsage               []*DynamicDurationPointerOpt
	OriginID               []*DynamicStringOpt
	AccountsForceUsage     []*DynamicBoolOpt
	AccountsAuthorize      []*DynamicBoolOpt
	AccountsInitialize     []*DynamicBoolOpt
	AccountsUpdate         []*DynamicBoolOpt
	AccountsTerminate      []*DynamicBoolOpt
}

// SessionSCfg is the config section for SessionS
type SessionSCfg struct {
	Enabled             bool
	ListenBiJSON        string
	ListenBiGob         string
	ChargerSConns       []string
	ResourceSConns      []string
	IPsConns            []string
	ThresholdSConns     []string
	StatSConns          []string
	RouteSConns         []string
	AttributeSConns     []string
	CDRsConns           []string
	ReplicationConns    []string
	RateSConns          []string
	AccountSConns       []string
	StoreSCosts         bool
	SessionIndexes      utils.StringSet
	ClientProtocol      float64
	ChannelSyncInterval time.Duration
	TerminateAttempts   int
	AlterableFields     utils.StringSet
	MinDurLowBalance    time.Duration
	ActionSConns        []string
	STIRCfg             *STIRcfg
	DefaultUsage        map[string]time.Duration
	Opts                *SessionsOpts
}

// loadSessionSCfg loads the SessionS section of the configuration
func (scfg *SessionSCfg) Load(ctx *context.Context, jsnCfg ConfigDB, _ *CGRConfig) (err error) {
	jsnSessionSCfg := new(SessionSJsonCfg)
	if err = jsnCfg.GetSection(ctx, SessionSJSON, jsnSessionSCfg); err != nil {
		return
	}
	return scfg.loadFromJSONCfg(jsnSessionSCfg)
}

func (sesOpts *SessionsOpts) loadFromJSONCfg(jsnCfg *SessionsOptsJson) error {
	if jsnCfg == nil {
		return nil
	}
	if jsnCfg.Accounts != nil {
		opt, err := IfaceToBoolDynamicOpts(jsnCfg.Accounts)
		if err != nil {
			return err
		}
		sesOpts.Accounts = append(opt, sesOpts.Accounts...)
	}
	if jsnCfg.Attributes != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.Attributes)
		if err != nil {
			return err
		}
		sesOpts.Attributes = append(opts, sesOpts.Attributes...)
	}
	if jsnCfg.CDRs != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.CDRs)
		if err != nil {
			return err
		}
		sesOpts.CDRs = append(opts, sesOpts.CDRs...)
	}
	if jsnCfg.Chargers != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.Chargers)
		if err != nil {
			return err
		}
		sesOpts.Chargers = append(opts, sesOpts.Chargers...)
	}
	if jsnCfg.Resources != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.Resources)
		if err != nil {
			return err
		}
		sesOpts.Resources = append(opts, sesOpts.Resources...)
	}
	if jsnCfg.IPs != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.IPs)
		if err != nil {
			return err
		}
		sesOpts.IPs = append(opts, sesOpts.IPs...)
	}
	if jsnCfg.Routes != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.Chargers)
		if err != nil {
			return err
		}
		sesOpts.Routes = append(opts, sesOpts.Routes...)
	}
	if jsnCfg.Stats != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.Stats)
		if err != nil {
			return err
		}
		sesOpts.Stats = append(opts, sesOpts.Stats...)
	}
	if jsnCfg.Thresholds != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.Thresholds)
		if err != nil {
			return err
		}
		sesOpts.Thresholds = append(opts, sesOpts.Thresholds...)
	}
	if jsnCfg.Initiate != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.Initiate)
		if err != nil {
			return err
		}
		sesOpts.Initiate = append(opts, sesOpts.Initiate...)
	}
	if jsnCfg.Update != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.Update)
		if err != nil {
			return err
		}
		sesOpts.Update = append(opts, sesOpts.Update...)
	}
	if jsnCfg.Terminate != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.Terminate)
		if err != nil {
			return err
		}
		sesOpts.Terminate = append(opts, sesOpts.Terminate...)
	}
	if jsnCfg.Message != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.Message)
		if err != nil {
			return err
		}
		sesOpts.Message = append(opts, sesOpts.Message...)
	}
	if jsnCfg.AttributesDerivedReply != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.AttributesDerivedReply)
		if err != nil {
			return err
		}
		sesOpts.AttributesDerivedReply = append(opts, sesOpts.AttributesDerivedReply...)
	}
	if jsnCfg.BlockerError != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.BlockerError)
		if err != nil {
			return err
		}
		sesOpts.BlockerError = append(opts, sesOpts.BlockerError...)
	}
	if jsnCfg.CDRsDerivedReply != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.CDRsDerivedReply)
		if err != nil {
			return err
		}
		sesOpts.CDRsDerivedReply = append(opts, sesOpts.CDRsDerivedReply...)
	}
	if jsnCfg.ResourcesAuthorize != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.ResourcesAuthorize)
		if err != nil {
			return err
		}
		sesOpts.ResourcesAuthorize = append(opts, sesOpts.ResourcesAuthorize...)
	}
	if jsnCfg.ResourcesAllocate != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.ResourcesAllocate)
		if err != nil {
			return err
		}
		sesOpts.ResourcesAllocate = append(opts, sesOpts.ResourcesAllocate...)
	}
	if jsnCfg.ResourcesRelease != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.ResourcesAllocate)
		if err != nil {
			return err
		}
		sesOpts.ResourcesRelease = append(opts, sesOpts.ResourcesRelease...)
	}
	if jsnCfg.ResourcesDerivedReply != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.ResourcesDerivedReply)
		if err != nil {
			return err
		}
		sesOpts.ResourcesDerivedReply = append(opts, sesOpts.ResourcesDerivedReply...)
	}
	if jsnCfg.IPsAuthorize != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.IPsAuthorize)
		if err != nil {
			return err
		}
		sesOpts.IPsAuthorize = append(opts, sesOpts.IPsAuthorize...)
	}
	if jsnCfg.IPsAllocate != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.IPsAllocate)
		if err != nil {
			return err
		}
		sesOpts.IPsAllocate = append(opts, sesOpts.IPsAllocate...)
	}
	if jsnCfg.IPsRelease != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.IPsAllocate)
		if err != nil {
			return err
		}
		sesOpts.IPsRelease = append(opts, sesOpts.IPsRelease...)
	}
	if jsnCfg.RoutesDerivedReply != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.RoutesDerivedReply)
		if err != nil {
			return err
		}
		sesOpts.RoutesDerivedReply = append(opts, sesOpts.RoutesDerivedReply...)
	}
	if jsnCfg.StatsDerivedReply != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.StatsDerivedReply)
		if err != nil {
			return err
		}
		sesOpts.StatsDerivedReply = append(opts, sesOpts.StatsDerivedReply...)
	}
	if jsnCfg.ThresholdsDerivedReply != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.ThresholdsDerivedReply)
		if err != nil {
			return err
		}
		sesOpts.ThresholdsDerivedReply = append(opts, sesOpts.ThresholdsDerivedReply...)
	}
	if jsnCfg.MaxUsage != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.MaxUsage)
		if err != nil {
			return err
		}
		sesOpts.MaxUsage = append(opts, sesOpts.MaxUsage...)
	}
	if jsnCfg.ForceUsage != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.ForceUsage)
		if err != nil {
			return err
		}
		sesOpts.ForceUsage = append(opts, sesOpts.ForceUsage...)
	}
	if jsnCfg.TTL != nil {
		ttl, err := IfaceToDurationDynamicOpts(jsnCfg.TTL)
		if err != nil {
			return err
		}
		sesOpts.TTL = append(ttl, sesOpts.TTL...)
	}
	if jsnCfg.Chargeable != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.Chargeable)
		if err != nil {
			return err
		}
		sesOpts.Chargeable = append(opts, sesOpts.Chargeable...)
	}
	if jsnCfg.TTLLastUsage != nil {
		lastUsage, err := IfaceToDurationPointerDynamicOpts(jsnCfg.TTLLastUsage)
		if err != nil {
			return err
		}
		sesOpts.TTLLastUsage = append(lastUsage, sesOpts.TTLLastUsage...)
	}
	if jsnCfg.TTLLastUsed != nil {
		lastUsed, err := IfaceToDurationPointerDynamicOpts(jsnCfg.TTLLastUsed)
		if err != nil {
			return err
		}
		sesOpts.TTLLastUsed = append(lastUsed, sesOpts.TTLLastUsed...)
	}
	if jsnCfg.DebitInterval != nil {
		debitInterval, err := IfaceToDurationDynamicOpts(jsnCfg.DebitInterval)
		if err != nil {
			return err
		}
		sesOpts.DebitInterval = append(debitInterval, sesOpts.DebitInterval...)
	}
	if jsnCfg.TTLMaxDelay != nil {
		maxDelay, err := IfaceToDurationDynamicOpts(jsnCfg.TTLMaxDelay)
		if err != nil {
			return err
		}
		sesOpts.TTLMaxDelay = append(maxDelay, sesOpts.TTLMaxDelay...)
	}
	if jsnCfg.TTLUsage != nil {
		usage, err := IfaceToDurationPointerDynamicOpts(jsnCfg.TTLUsage)
		if err != nil {
			return err
		}
		sesOpts.TTLUsage = append(usage, sesOpts.TTLUsage...)
	}
	if jsnCfg.OriginID != nil {
		originID, err := InterfaceToDynamicStringOpts(jsnCfg.OriginID)
		if err != nil {
			return err
		}
		sesOpts.OriginID = append(originID, sesOpts.OriginID...)
	}
	if jsnCfg.AccountsForceUsage != nil {
		opts, err := IfaceToBoolDynamicOpts(jsnCfg.AccountsForceUsage)
		if err != nil {
			return err
		}
		sesOpts.AccountsForceUsage = append(opts, sesOpts.AccountsForceUsage...)
	}
	return nil
}

func (scfg *SessionSCfg) loadFromJSONCfg(jsnCfg *SessionSJsonCfg) (err error) {
	if jsnCfg == nil {
		return nil
	}
	if jsnCfg.Enabled != nil {
		scfg.Enabled = *jsnCfg.Enabled
	}
	if jsnCfg.ListenBiJSON != nil {
		scfg.ListenBiJSON = *jsnCfg.ListenBiJSON
	}
	if jsnCfg.ListenBiGob != nil {
		scfg.ListenBiGob = *jsnCfg.ListenBiGob
	}
	if jsnCfg.ChargerSConns != nil {
		scfg.ChargerSConns = tagInternalConns(*jsnCfg.ChargerSConns, utils.MetaChargers)
	}
	if jsnCfg.ResourceSConns != nil {
		scfg.ResourceSConns = tagInternalConns(*jsnCfg.ResourceSConns, utils.MetaResources)
	}
	if jsnCfg.IPsConns != nil {
		scfg.IPsConns = tagInternalConns(*jsnCfg.IPsConns, utils.MetaIPs)
	}
	if jsnCfg.ThresholdSConns != nil {
		scfg.ThresholdSConns = tagInternalConns(*jsnCfg.ThresholdSConns, utils.MetaThresholds)
	}
	if jsnCfg.StatSConns != nil {
		scfg.StatSConns = tagInternalConns(*jsnCfg.StatSConns, utils.MetaStats)
	}
	if jsnCfg.RouteSConns != nil {
		scfg.RouteSConns = tagInternalConns(*jsnCfg.RouteSConns, utils.MetaRoutes)
	}
	if jsnCfg.AttributeSConns != nil {
		scfg.AttributeSConns = tagInternalConns(*jsnCfg.AttributeSConns, utils.MetaAttributes)
	}
	if jsnCfg.CDRsConns != nil {
		scfg.CDRsConns = tagInternalConns(*jsnCfg.CDRsConns, utils.MetaCDRs)
	}
	if jsnCfg.ActionSConns != nil {
		scfg.ActionSConns = tagInternalConns(*jsnCfg.ActionSConns, utils.MetaActions)
	}
	if jsnCfg.ReplicationConns != nil {
		scfg.ReplicationConns = make([]string, len(*jsnCfg.ReplicationConns))
		for idx, connID := range *jsnCfg.ReplicationConns {
			if connID == utils.MetaInternal {
				return fmt.Errorf("Replication connection ID needs to be different than *internal ")
			}
			scfg.ReplicationConns[idx] = connID
		}
	}
	if jsnCfg.RateSConns != nil {
		scfg.RateSConns = tagInternalConns(*jsnCfg.RateSConns, utils.MetaRates)
	}
	if jsnCfg.AccountSConns != nil {
		scfg.AccountSConns = tagInternalConns(*jsnCfg.AccountSConns, utils.MetaAccounts)
	}
	if jsnCfg.StoreSCosts != nil {
		scfg.StoreSCosts = *jsnCfg.StoreSCosts
	}
	if jsnCfg.SessionIndexes != nil {
		scfg.SessionIndexes = utils.NewStringSet(*jsnCfg.SessionIndexes)
	}
	if jsnCfg.ClientProtocol != nil {
		scfg.ClientProtocol = *jsnCfg.ClientProtocol
	}
	if jsnCfg.ChannelSyncInterval != nil {
		if scfg.ChannelSyncInterval, err = utils.ParseDurationWithNanosecs(*jsnCfg.ChannelSyncInterval); err != nil {
			return err
		}
	}
	if jsnCfg.TerminateAttempts != nil {
		scfg.TerminateAttempts = *jsnCfg.TerminateAttempts
	}
	if jsnCfg.AlterableFields != nil {
		scfg.AlterableFields = utils.NewStringSet(*jsnCfg.AlterableFields)
	}
	if jsnCfg.MinDurLowBalance != nil {
		if scfg.MinDurLowBalance, err = utils.ParseDurationWithNanosecs(*jsnCfg.MinDurLowBalance); err != nil {
			return err
		}
	}
	if jsnCfg.DefaultUsage != nil {
		for k, v := range jsnCfg.DefaultUsage {
			if scfg.DefaultUsage[k], err = utils.ParseDurationWithNanosecs(v); err != nil {
				return
			}
		}
	}
	if jsnCfg.Stir != nil {
		if err = scfg.STIRCfg.loadFromJSONCfg(jsnCfg.Stir); err != nil {
			return
		}
	}
	if jsnCfg.Opts != nil {
		if err = scfg.Opts.loadFromJSONCfg(jsnCfg.Opts); err != nil {
			return
		}
	}
	return
}

func (scfg SessionSCfg) GetDefaultUsage(tor string) time.Duration {
	if tor == utils.EmptyString {
		tor = utils.MetaAny
	}
	return scfg.DefaultUsage[tor]
}

// AsMapInterface returns the config as a map[string]any
func (scfg SessionSCfg) AsMapInterface() any {
	maxComputed := make(map[string]string)
	for key, item := range scfg.DefaultUsage {
		if key == utils.MetaAny || key == utils.MetaVoice {
			maxComputed[key] = item.String()
		} else {
			maxComputed[key] = strconv.Itoa(int(item))
		}
	}
	opts := map[string]any{
		utils.MetaAccounts:                  scfg.Opts.Accounts,
		utils.MetaAttributes:                scfg.Opts.Attributes,
		utils.MetaCDRs:                      scfg.Opts.CDRs,
		utils.MetaChargers:                  scfg.Opts.Chargers,
		utils.MetaResources:                 scfg.Opts.Resources,
		utils.MetaIPs:                       scfg.Opts.IPs,
		utils.MetaRoutes:                    scfg.Opts.Routes,
		utils.MetaStats:                     scfg.Opts.Stats,
		utils.MetaThresholds:                scfg.Opts.Thresholds,
		utils.MetaInitiate:                  scfg.Opts.Initiate,
		utils.MetaUpdate:                    scfg.Opts.Update,
		utils.MetaTerminate:                 scfg.Opts.Terminate,
		utils.MetaMessage:                   scfg.Opts.Message,
		utils.MetaAttributesDerivedReplyCfg: scfg.Opts.AttributesDerivedReply,
		utils.MetaBlockerErrorCfg:           scfg.Opts.BlockerError,
		utils.MetaCDRsDerivedReplyCfg:       scfg.Opts.CDRsDerivedReply,
		utils.MetaResourcesAuthorizeCfg:     scfg.Opts.ResourcesAuthorize,
		utils.MetaResourcesAllocateCfg:      scfg.Opts.ResourcesAllocate,
		utils.MetaResourcesReleaseCfg:       scfg.Opts.ResourcesRelease,
		utils.MetaResourcesDerivedReplyCfg:  scfg.Opts.ResourcesDerivedReply,
		utils.MetaIPsAuthorizeCfg:           scfg.Opts.IPsAuthorize,
		utils.MetaIPsAllocateCfg:            scfg.Opts.IPsAllocate,
		utils.MetaIPsReleaseCfg:             scfg.Opts.IPsRelease,
		utils.MetaRoutesDerivedReplyCfg:     scfg.Opts.RoutesDerivedReply,
		utils.MetaStatsDerivedReplyCfg:      scfg.Opts.StatsDerivedReply,
		utils.MetaThresholdsDerivedReplyCfg: scfg.Opts.ThresholdsDerivedReply,
		utils.MetaMaxUsageCfg:               scfg.Opts.MaxUsage,
		utils.MetaForceUsageCfg:             scfg.Opts.ForceUsage,
		utils.MetaTTLCfg:                    scfg.Opts.TTL,
		utils.MetaChargeableCfg:             scfg.Opts.Chargeable,
		utils.MetaDebitIntervalCfg:          scfg.Opts.DebitInterval,
		utils.MetaTTLLastUsageCfg:           scfg.Opts.TTLLastUsage,
		utils.MetaTTLLastUsedCfg:            scfg.Opts.TTLLastUsed,
		utils.MetaTTLMaxDelayCfg:            scfg.Opts.TTLMaxDelay,
		utils.MetaTTLUsageCfg:               scfg.Opts.TTLUsage,
		utils.MetaOriginID:                  scfg.Opts.OriginID,
		utils.MetaAccountsForceUsage:        scfg.Opts.AccountsForceUsage,
	}
	mp := map[string]any{
		utils.EnabledCfg:             scfg.Enabled,
		utils.ListenBijsonCfg:        scfg.ListenBiJSON,
		utils.ListenBigobCfg:         scfg.ListenBiGob,
		utils.ReplicationConnsCfg:    scfg.ReplicationConns,
		utils.StoreSCostsCfg:         scfg.StoreSCosts,
		utils.SessionIndexesCfg:      scfg.SessionIndexes.AsSlice(),
		utils.ClientProtocolCfg:      scfg.ClientProtocol,
		utils.TerminateAttemptsCfg:   scfg.TerminateAttempts,
		utils.AlterableFieldsCfg:     scfg.AlterableFields.AsSlice(),
		utils.STIRCfg:                scfg.STIRCfg.AsMapInterface(),
		utils.MinDurLowBalanceCfg:    "0",
		utils.ChannelSyncIntervalCfg: "0",
		utils.DefaultUsageCfg:        maxComputed,
		utils.OptsCfg:                opts,
	}
	if scfg.ChannelSyncInterval != 0 {
		mp[utils.ChannelSyncIntervalCfg] = scfg.ChannelSyncInterval.String()
	}
	if scfg.MinDurLowBalance != 0 {
		mp[utils.MinDurLowBalanceCfg] = scfg.MinDurLowBalance.String()
	}
	if scfg.ChargerSConns != nil {
		mp[utils.ChargerSConnsCfg] = stripInternalConns(scfg.ChargerSConns)
	}
	if scfg.ResourceSConns != nil {
		mp[utils.ResourceSConnsCfg] = stripInternalConns(scfg.ResourceSConns)
	}
	if scfg.IPsConns != nil {
		mp[utils.IPsConnsCfg] = stripInternalConns(scfg.IPsConns)
	}
	if scfg.ThresholdSConns != nil {
		mp[utils.ThresholdSConnsCfg] = stripInternalConns(scfg.ThresholdSConns)
	}
	if scfg.StatSConns != nil {
		mp[utils.StatSConnsCfg] = stripInternalConns(scfg.StatSConns)
	}
	if scfg.RouteSConns != nil {
		mp[utils.RouteSConnsCfg] = stripInternalConns(scfg.RouteSConns)
	}
	if scfg.AttributeSConns != nil {
		mp[utils.AttributeSConnsCfg] = stripInternalConns(scfg.AttributeSConns)
	}
	if scfg.CDRsConns != nil {
		mp[utils.CDRsConnsCfg] = stripInternalConns(scfg.CDRsConns)
	}
	if scfg.ActionSConns != nil {
		mp[utils.ActionSConnsCfg] = stripInternalConns(scfg.ActionSConns)
	}
	if scfg.RateSConns != nil {
		mp[utils.RateSConnsCfg] = stripInternalConns(scfg.RateSConns)
	}
	if scfg.AccountSConns != nil {
		mp[utils.AccountSConnsCfg] = stripInternalConns(scfg.AccountSConns)
	}
	return mp
}

func (SessionSCfg) SName() string              { return SessionSJSON }
func (scfg SessionSCfg) CloneSection() Section { return scfg.Clone() }

func (o *SessionsOpts) Clone() *SessionsOpts {
	return &SessionsOpts{
		Accounts:               CloneDynamicBoolOpt(o.Accounts),
		Attributes:             CloneDynamicBoolOpt(o.Attributes),
		CDRs:                   CloneDynamicBoolOpt(o.CDRs),
		Chargers:               CloneDynamicBoolOpt(o.Chargers),
		Resources:              CloneDynamicBoolOpt(o.Resources),
		IPs:                    CloneDynamicBoolOpt(o.IPs),
		Routes:                 CloneDynamicBoolOpt(o.Routes),
		Stats:                  CloneDynamicBoolOpt(o.Stats),
		Thresholds:             CloneDynamicBoolOpt(o.Thresholds),
		Initiate:               CloneDynamicBoolOpt(o.Initiate),
		Update:                 CloneDynamicBoolOpt(o.Update),
		Terminate:              CloneDynamicBoolOpt(o.Terminate),
		Message:                CloneDynamicBoolOpt(o.Message),
		AttributesDerivedReply: CloneDynamicBoolOpt(o.AttributesDerivedReply),
		BlockerError:           CloneDynamicBoolOpt(o.BlockerError),
		CDRsDerivedReply:       CloneDynamicBoolOpt(o.CDRsDerivedReply),
		ResourcesAuthorize:     CloneDynamicBoolOpt(o.ResourcesAuthorize),
		ResourcesAllocate:      CloneDynamicBoolOpt(o.ResourcesAllocate),
		ResourcesRelease:       CloneDynamicBoolOpt(o.ResourcesRelease),
		ResourcesDerivedReply:  CloneDynamicBoolOpt(o.ResourcesDerivedReply),
		IPsAuthorize:           CloneDynamicBoolOpt(o.IPsAuthorize),
		IPsAllocate:            CloneDynamicBoolOpt(o.IPsAllocate),
		IPsRelease:             CloneDynamicBoolOpt(o.IPsRelease),
		RoutesDerivedReply:     CloneDynamicBoolOpt(o.RoutesDerivedReply),
		StatsDerivedReply:      CloneDynamicBoolOpt(o.StatsDerivedReply),
		ThresholdsDerivedReply: CloneDynamicBoolOpt(o.ThresholdsDerivedReply),
		MaxUsage:               CloneDynamicBoolOpt(o.MaxUsage),
		ForceUsage:             CloneDynamicBoolOpt(o.ForceUsage),
		TTL:                    CloneDynamicDurationOpt(o.TTL),
		Chargeable:             CloneDynamicBoolOpt(o.Chargeable),
		DebitInterval:          CloneDynamicDurationOpt(o.DebitInterval),
		TTLLastUsage:           CloneDynamicDurationPointerOpt(o.TTLLastUsage),
		TTLLastUsed:            CloneDynamicDurationPointerOpt(o.TTLLastUsed),
		TTLMaxDelay:            CloneDynamicDurationOpt(o.TTLMaxDelay),
		TTLUsage:               CloneDynamicDurationPointerOpt(o.TTLUsage),
		OriginID:               CloneDynamicStringOpt(o.OriginID),
		AccountsForceUsage:     CloneDynamicBoolOpt(o.AccountsForceUsage),
	}
}

// Clone returns a deep copy of SessionSCfg
func (scfg SessionSCfg) Clone() (cln *SessionSCfg) {
	cln = &SessionSCfg{
		Enabled:             scfg.Enabled,
		ListenBiJSON:        scfg.ListenBiJSON,
		StoreSCosts:         scfg.StoreSCosts,
		ClientProtocol:      scfg.ClientProtocol,
		ChannelSyncInterval: scfg.ChannelSyncInterval,
		TerminateAttempts:   scfg.TerminateAttempts,
		MinDurLowBalance:    scfg.MinDurLowBalance,

		SessionIndexes:  scfg.SessionIndexes.Clone(),
		AlterableFields: scfg.AlterableFields.Clone(),
		STIRCfg:         scfg.STIRCfg.Clone(),
		DefaultUsage:    make(map[string]time.Duration),
		Opts:            scfg.Opts.Clone(),
	}
	for k, v := range scfg.DefaultUsage {
		cln.DefaultUsage[k] = v
	}
	if scfg.ChargerSConns != nil {
		cln.ChargerSConns = slices.Clone(scfg.ChargerSConns)
	}
	if scfg.ResourceSConns != nil {
		cln.ResourceSConns = slices.Clone(scfg.ResourceSConns)
	}
	if scfg.IPsConns != nil {
		cln.IPsConns = slices.Clone(scfg.IPsConns)
	}
	if scfg.ThresholdSConns != nil {
		cln.ThresholdSConns = slices.Clone(scfg.ThresholdSConns)
	}
	if scfg.StatSConns != nil {
		cln.StatSConns = slices.Clone(scfg.StatSConns)
	}
	if scfg.RouteSConns != nil {
		cln.RouteSConns = slices.Clone(scfg.RouteSConns)
	}
	if scfg.AttributeSConns != nil {
		cln.AttributeSConns = slices.Clone(scfg.AttributeSConns)
	}
	if scfg.CDRsConns != nil {
		cln.CDRsConns = slices.Clone(scfg.CDRsConns)
	}
	if scfg.ReplicationConns != nil {
		cln.ReplicationConns = slices.Clone(scfg.ReplicationConns)
	}
	if scfg.ActionSConns != nil {
		cln.ActionSConns = slices.Clone(scfg.ActionSConns)
	}
	if scfg.RateSConns != nil {
		cln.RateSConns = slices.Clone(scfg.RateSConns)
	}
	if scfg.AccountSConns != nil {
		cln.AccountSConns = slices.Clone(scfg.AccountSConns)
	}

	return
}

// STIRcfg the confuguration structure for STIR
type STIRcfg struct {
	AllowedAttest      utils.StringSet
	PayloadMaxduration time.Duration
	DefaultAttest      string
	PublicKeyPath      string
	PrivateKeyPath     string
}

func (stirCfg *STIRcfg) loadFromJSONCfg(jsnCfg *STIRJsonCfg) (err error) {
	if jsnCfg == nil {
		return nil
	}
	if jsnCfg.Allowed_attest != nil {
		stirCfg.AllowedAttest = utils.NewStringSet(*jsnCfg.Allowed_attest)
	}
	if jsnCfg.Payload_maxduration != nil {
		if stirCfg.PayloadMaxduration, err = utils.ParseDurationWithNanosecs(*jsnCfg.Payload_maxduration); err != nil {
			return err
		}
	}
	if jsnCfg.Default_attest != nil {
		stirCfg.DefaultAttest = *jsnCfg.Default_attest
	}
	if jsnCfg.Publickey_path != nil {
		stirCfg.PublicKeyPath = *jsnCfg.Publickey_path
	}
	if jsnCfg.Privatekey_path != nil {
		stirCfg.PrivateKeyPath = *jsnCfg.Privatekey_path
	}
	return nil
}

// AsMapInterface returns the config as a map[string]any
func (stirCfg *STIRcfg) AsMapInterface() (initialMP map[string]any) {
	initialMP = map[string]any{
		utils.DefaultAttestCfg:      stirCfg.DefaultAttest,
		utils.PublicKeyPathCfg:      stirCfg.PublicKeyPath,
		utils.PrivateKeyPathCfg:     stirCfg.PrivateKeyPath,
		utils.AllowedAtestCfg:       stirCfg.AllowedAttest.AsSlice(),
		utils.PayloadMaxdurationCfg: "0",
	}
	if stirCfg.PayloadMaxduration > 0 {
		initialMP[utils.PayloadMaxdurationCfg] = stirCfg.PayloadMaxduration.String()
	} else if stirCfg.PayloadMaxduration < 0 {
		initialMP[utils.PayloadMaxdurationCfg] = "-1"
	}
	return
}

// Clone returns a deep copy of STIRcfg
func (stirCfg STIRcfg) Clone() *STIRcfg {
	return &STIRcfg{
		AllowedAttest:      stirCfg.AllowedAttest.Clone(),
		PayloadMaxduration: stirCfg.PayloadMaxduration,
		DefaultAttest:      stirCfg.DefaultAttest,
		PublicKeyPath:      stirCfg.PublicKeyPath,
		PrivateKeyPath:     stirCfg.PrivateKeyPath,
	}
}

type STIRJsonCfg struct {
	Allowed_attest      *[]string
	Payload_maxduration *string
	Default_attest      *string
	Publickey_path      *string
	Privatekey_path     *string
}

func diffSTIRJsonCfg(d *STIRJsonCfg, v1, v2 *STIRcfg) *STIRJsonCfg {
	if d == nil {
		d = new(STIRJsonCfg)
	}
	if v1.AllowedAttest.Equals(v2.AllowedAttest) {
		d.Allowed_attest = nil
		if v2.AllowedAttest != nil {
			d.Allowed_attest = utils.SliceStringPointer(v2.AllowedAttest.AsSlice())
		}
	}
	if v1.PayloadMaxduration != v2.PayloadMaxduration {
		d.Payload_maxduration = utils.StringPointer(v2.PayloadMaxduration.String())
	}
	if v1.DefaultAttest != v2.DefaultAttest {
		d.Default_attest = utils.StringPointer(v2.DefaultAttest)
	}
	if v1.PublicKeyPath != v2.PublicKeyPath {
		d.Publickey_path = utils.StringPointer(v2.PublicKeyPath)
	}
	if v1.PrivateKeyPath != v2.PrivateKeyPath {
		d.Privatekey_path = utils.StringPointer(v2.PrivateKeyPath)
	}
	return d
}

type SessionsOptsJson struct {
	Accounts               []*DynamicInterfaceOpt `json:"*accounts"`
	Attributes             []*DynamicInterfaceOpt `json:"*attributes"`
	CDRs                   []*DynamicInterfaceOpt `json:"*cdrs"`
	Chargers               []*DynamicInterfaceOpt `json:"*chargers"`
	Resources              []*DynamicInterfaceOpt `json:"*resources"`
	IPs                    []*DynamicInterfaceOpt `json:"*ips"`
	Routes                 []*DynamicInterfaceOpt `json:"*routes"`
	Stats                  []*DynamicInterfaceOpt `json:"*stats"`
	Thresholds             []*DynamicInterfaceOpt `json:"*thresholds"`
	Initiate               []*DynamicInterfaceOpt `json:"*initiate"`
	Update                 []*DynamicInterfaceOpt `json:"*update"`
	Terminate              []*DynamicInterfaceOpt `json:"*terminate"`
	Message                []*DynamicInterfaceOpt `json:"*message"`
	AttributesDerivedReply []*DynamicInterfaceOpt `json:"*attributesDerivedReply"`
	BlockerError           []*DynamicInterfaceOpt `json:"*blockerError"`
	CDRsDerivedReply       []*DynamicInterfaceOpt `json:"*cdrsDerivedReply"`
	ResourcesAuthorize     []*DynamicInterfaceOpt `json:"*resourcesAuthorize"`
	ResourcesAllocate      []*DynamicInterfaceOpt `json:"*resourcesAllocate"`
	ResourcesRelease       []*DynamicInterfaceOpt `json:"*resourcesRelease"`
	ResourcesDerivedReply  []*DynamicInterfaceOpt `json:"*resourcesDerivedReply"`
	IPsAuthorize           []*DynamicInterfaceOpt `json:"*ipsAuthorize"`
	IPsAllocate            []*DynamicInterfaceOpt `json:"*ipsAllocate"`
	IPsRelease             []*DynamicInterfaceOpt `json:"*ipsRelease"`
	RoutesDerivedReply     []*DynamicInterfaceOpt `json:"*routesDerivedReply"`
	StatsDerivedReply      []*DynamicInterfaceOpt `json:"*statsDerivedReply"`
	ThresholdsDerivedReply []*DynamicInterfaceOpt `json:"*thresholdsDerivedReply"`
	MaxUsage               []*DynamicInterfaceOpt `json:"*maxUsage"`
	ForceUsage             []*DynamicInterfaceOpt `json:"*forceUsage"`
	TTL                    []*DynamicInterfaceOpt `json:"*ttl"`
	Chargeable             []*DynamicInterfaceOpt `json:"*chargeable"`
	DebitInterval          []*DynamicInterfaceOpt `json:"*debitInterval"`
	TTLLastUsage           []*DynamicInterfaceOpt `json:"*ttlLastUsage"`
	TTLLastUsed            []*DynamicInterfaceOpt `json:"*ttlLastUsed"`
	TTLMaxDelay            []*DynamicInterfaceOpt `json:"*ttlMaxDelay"`
	TTLUsage               []*DynamicInterfaceOpt `json:"*ttlUsage"`
	OriginID               []*DynamicInterfaceOpt `json:"*originID"`
	AccountsForceUsage     []*DynamicInterfaceOpt `json:"*accountsForceUsage"`
}

// SessionSJsonCfg config section
type SessionSJsonCfg struct {
	Enabled             *bool             `json:"enabled"`
	ListenBiJSON        *string           `json:"listen_bijson"`
	ListenBiGob         *string           `json:"listen_bigob"`
	ChargerSConns       *[]string         `json:"chargers_conns"`
	ResourceSConns      *[]string         `json:"resources_conns"`
	IPsConns            *[]string         `json:"ips_conns"`
	ThresholdSConns     *[]string         `json:"thresholds_conns"`
	StatSConns          *[]string         `json:"stats_conns"`
	RouteSConns         *[]string         `json:"routes_conns"`
	CDRsConns           *[]string         `json:"cdrs_conns"`
	ReplicationConns    *[]string         `json:"replication_conns"`
	AttributeSConns     *[]string         `json:"attributes_conns"`
	ActionSConns        *[]string         `json:"actions_conns"`
	RateSConns          *[]string         `json:"rates_conns"`
	AccountSConns       *[]string         `json:"accounts_conns"`
	StoreSCosts         *bool             `json:"store_session_costs"`
	SessionIndexes      *[]string         `json:"session_indexes"`
	ClientProtocol      *float64          `json:"client_protocol"`
	ChannelSyncInterval *string           `json:"channel_sync_interval"`
	TerminateAttempts   *int              `json:"terminate_attempts"`
	AlterableFields     *[]string         `json:"alterable_fields"`
	MinDurLowBalance    *string           `json:"min_dur_low_balance"`
	Stir                *STIRJsonCfg      `json:"stir"`
	DefaultUsage        map[string]string `json:"default_usage"`
	Opts                *SessionsOptsJson `json:"opts"`
}

func diffSessionsOptsJsonCfg(d *SessionsOptsJson, v1, v2 *SessionsOpts) *SessionsOptsJson {
	if d == nil {
		d = new(SessionsOptsJson)
	}
	if !DynamicBoolOptEqual(v1.Accounts, v2.Accounts) {
		d.Accounts = BoolToIfaceDynamicOpts(v2.Accounts)
	}
	if !DynamicBoolOptEqual(v1.Attributes, v2.Attributes) {
		d.Attributes = BoolToIfaceDynamicOpts(v2.Attributes)
	}
	if !DynamicBoolOptEqual(v1.CDRs, v2.CDRs) {
		d.CDRs = BoolToIfaceDynamicOpts(v2.CDRs)
	}
	if !DynamicBoolOptEqual(v1.Chargers, v2.Chargers) {
		d.Chargers = BoolToIfaceDynamicOpts(v2.Chargers)
	}
	if !DynamicBoolOptEqual(v1.Resources, v2.Resources) {
		d.Resources = BoolToIfaceDynamicOpts(v2.Resources)
	}
	if !DynamicBoolOptEqual(v1.IPs, v2.IPs) {
		d.IPs = BoolToIfaceDynamicOpts(v2.IPs)
	}
	if !DynamicBoolOptEqual(v1.Routes, v2.Routes) {
		d.Routes = BoolToIfaceDynamicOpts(v2.Routes)
	}
	if !DynamicBoolOptEqual(v1.Stats, v2.Stats) {
		d.Stats = BoolToIfaceDynamicOpts(v2.Stats)
	}
	if !DynamicBoolOptEqual(v1.Thresholds, v2.Thresholds) {
		d.Thresholds = BoolToIfaceDynamicOpts(v2.Thresholds)
	}
	if !DynamicBoolOptEqual(v1.Initiate, v2.Initiate) {
		d.Initiate = BoolToIfaceDynamicOpts(v2.Initiate)
	}
	if !DynamicBoolOptEqual(v1.Update, v2.Update) {
		d.Update = BoolToIfaceDynamicOpts(v2.Update)
	}
	if !DynamicBoolOptEqual(v1.Terminate, v2.Terminate) {
		d.Terminate = BoolToIfaceDynamicOpts(v2.Terminate)
	}
	if !DynamicBoolOptEqual(v1.Message, v2.Message) {
		d.Message = BoolToIfaceDynamicOpts(v2.Message)
	}
	if !DynamicBoolOptEqual(v1.AttributesDerivedReply, v2.AttributesDerivedReply) {
		d.AttributesDerivedReply = BoolToIfaceDynamicOpts(v2.AttributesDerivedReply)
	}
	if !DynamicBoolOptEqual(v1.BlockerError, v2.BlockerError) {
		d.BlockerError = BoolToIfaceDynamicOpts(v2.BlockerError)
	}
	if !DynamicBoolOptEqual(v1.CDRsDerivedReply, v2.CDRsDerivedReply) {
		d.CDRsDerivedReply = BoolToIfaceDynamicOpts(v2.CDRsDerivedReply)
	}
	if !DynamicBoolOptEqual(v1.ResourcesAuthorize, v2.ResourcesAuthorize) {
		d.ResourcesAuthorize = BoolToIfaceDynamicOpts(v2.ResourcesAuthorize)
	}
	if !DynamicBoolOptEqual(v1.ResourcesAllocate, v2.ResourcesAllocate) {
		d.ResourcesAllocate = BoolToIfaceDynamicOpts(v2.ResourcesAllocate)
	}
	if !DynamicBoolOptEqual(v1.ResourcesRelease, v2.ResourcesRelease) {
		d.ResourcesRelease = BoolToIfaceDynamicOpts(v2.ResourcesRelease)
	}
	if !DynamicBoolOptEqual(v1.ResourcesDerivedReply, v2.ResourcesDerivedReply) {
		d.ResourcesDerivedReply = BoolToIfaceDynamicOpts(v2.ResourcesDerivedReply)
	}
	if !DynamicBoolOptEqual(v1.IPsAuthorize, v2.IPsAuthorize) {
		d.IPsAuthorize = BoolToIfaceDynamicOpts(v2.IPsAuthorize)
	}
	if !DynamicBoolOptEqual(v1.IPsAllocate, v2.IPsAllocate) {
		d.IPsAllocate = BoolToIfaceDynamicOpts(v2.IPsAllocate)
	}
	if !DynamicBoolOptEqual(v1.IPsRelease, v2.IPsRelease) {
		d.IPsRelease = BoolToIfaceDynamicOpts(v2.IPsRelease)
	}
	if !DynamicBoolOptEqual(v1.RoutesDerivedReply, v2.RoutesDerivedReply) {
		d.RoutesDerivedReply = BoolToIfaceDynamicOpts(v2.RoutesDerivedReply)
	}
	if !DynamicBoolOptEqual(v1.StatsDerivedReply, v2.StatsDerivedReply) {
		d.StatsDerivedReply = BoolToIfaceDynamicOpts(v2.StatsDerivedReply)
	}
	if !DynamicBoolOptEqual(v1.ThresholdsDerivedReply, v2.ThresholdsDerivedReply) {
		d.ThresholdsDerivedReply = BoolToIfaceDynamicOpts(v2.ThresholdsDerivedReply)
	}
	if !DynamicBoolOptEqual(v1.MaxUsage, v2.MaxUsage) {
		d.MaxUsage = BoolToIfaceDynamicOpts(v2.MaxUsage)
	}
	if !DynamicBoolOptEqual(v1.ForceUsage, v2.ForceUsage) {
		d.ForceUsage = BoolToIfaceDynamicOpts(v2.ForceUsage)
	}
	if !DynamicDurationOptEqual(v1.TTL, v2.TTL) {
		d.TTL = DurationToIfaceDynamicOpts(v2.TTL)
	}
	if !DynamicBoolOptEqual(v1.Chargeable, v2.Chargeable) {
		d.Chargeable = BoolToIfaceDynamicOpts(v2.Chargeable)
	}
	if !DynamicDurationPointerOptEqual(v1.TTLLastUsage, v2.TTLLastUsage) {
		d.TTLLastUsage = DurationPointerToIfaceDynamicOpts(v2.TTLLastUsage)
	}
	if !DynamicDurationPointerOptEqual(v1.TTLLastUsed, v2.TTLLastUsed) {
		d.TTLLastUsed = DurationPointerToIfaceDynamicOpts(v2.TTLLastUsed)
	}
	if !DynamicDurationOptEqual(v1.DebitInterval, v2.DebitInterval) {
		d.DebitInterval = DurationToIfaceDynamicOpts(v2.DebitInterval)
	}
	if !DynamicDurationOptEqual(v1.TTLMaxDelay, v2.TTLMaxDelay) {
		d.TTLMaxDelay = DurationToIfaceDynamicOpts(v2.TTLMaxDelay)
	}
	if !DynamicDurationPointerOptEqual(v1.TTLUsage, v2.TTLUsage) {
		d.TTLUsage = DurationPointerToIfaceDynamicOpts(v2.TTLUsage)
	}
	if !DynamicStringOptEqual(v1.OriginID, v2.OriginID) {
		d.OriginID = DynamicStringToInterfaceOpts(v2.OriginID)
	}
	if !DynamicBoolOptEqual(v1.AccountsForceUsage, v2.AccountsForceUsage) {
		d.AccountsForceUsage = BoolToIfaceDynamicOpts(v2.AccountsForceUsage)
	}
	return d
}

func diffSessionSJsonCfg(d *SessionSJsonCfg, v1, v2 *SessionSCfg) *SessionSJsonCfg {
	if d == nil {
		d = new(SessionSJsonCfg)
	}
	if v1.Enabled != v2.Enabled {
		d.Enabled = utils.BoolPointer(v2.Enabled)
	}
	if v1.ListenBiJSON != v2.ListenBiJSON {
		d.ListenBiJSON = utils.StringPointer(v2.ListenBiJSON)
	}
	if v1.ListenBiGob != v2.ListenBiGob {
		d.ListenBiGob = utils.StringPointer(v2.ListenBiGob)
	}
	if !slices.Equal(v1.ChargerSConns, v2.ChargerSConns) {
		d.ChargerSConns = utils.SliceStringPointer(stripInternalConns(v2.ChargerSConns))
	}
	if !slices.Equal(v1.ResourceSConns, v2.ResourceSConns) {
		d.ResourceSConns = utils.SliceStringPointer(stripInternalConns(v2.ResourceSConns))
	}
	if !slices.Equal(v1.IPsConns, v2.IPsConns) {
		d.IPsConns = utils.SliceStringPointer(stripInternalConns(v2.IPsConns))
	}
	if !slices.Equal(v1.ThresholdSConns, v2.ThresholdSConns) {
		d.ThresholdSConns = utils.SliceStringPointer(stripInternalConns(v2.ThresholdSConns))
	}
	if !slices.Equal(v1.StatSConns, v2.StatSConns) {
		d.StatSConns = utils.SliceStringPointer(stripInternalConns(v2.StatSConns))
	}
	if !slices.Equal(v1.RouteSConns, v2.RouteSConns) {
		d.RouteSConns = utils.SliceStringPointer(stripInternalConns(v2.RouteSConns))
	}
	if !slices.Equal(v1.AttributeSConns, v2.AttributeSConns) {
		d.CDRsConns = utils.SliceStringPointer(stripInternalConns(v2.AttributeSConns))
	}
	if !slices.Equal(v1.CDRsConns, v2.CDRsConns) {
		d.ReplicationConns = utils.SliceStringPointer(stripInternalConns(v2.CDRsConns))
	}
	if !slices.Equal(v1.ReplicationConns, v2.ReplicationConns) {
		d.AttributeSConns = utils.SliceStringPointer(v2.ReplicationConns)
	}
	if !slices.Equal(v1.RateSConns, v2.RateSConns) {
		d.RateSConns = utils.SliceStringPointer(stripInternalConns(v2.RateSConns))
	}
	if !slices.Equal(v1.AccountSConns, v2.AccountSConns) {
		d.AccountSConns = utils.SliceStringPointer(stripInternalConns(v2.AccountSConns))
	}
	if v1.StoreSCosts != v2.StoreSCosts {
		d.StoreSCosts = utils.BoolPointer(v2.StoreSCosts)
	}
	if !v1.SessionIndexes.Equals(v2.SessionIndexes) {
		d.SessionIndexes = utils.SliceStringPointer(v2.SessionIndexes.AsSlice())
	}
	if v1.ClientProtocol != v2.ClientProtocol {
		d.ClientProtocol = utils.Float64Pointer(v2.ClientProtocol)
	}
	if v1.ChannelSyncInterval != v2.ChannelSyncInterval {
		d.ChannelSyncInterval = utils.StringPointer(v2.ChannelSyncInterval.String())
	}
	if v1.TerminateAttempts != v2.TerminateAttempts {
		d.TerminateAttempts = utils.IntPointer(v2.TerminateAttempts)
	}
	if !v1.AlterableFields.Equals(v2.AlterableFields) {
		d.AlterableFields = utils.SliceStringPointer(v2.AlterableFields.AsSlice())
	}
	if v1.MinDurLowBalance != v2.MinDurLowBalance {
		d.MinDurLowBalance = utils.StringPointer(v2.MinDurLowBalance.String())
	}
	if !slices.Equal(v1.ActionSConns, v2.ActionSConns) {
		d.ActionSConns = utils.SliceStringPointer(stripInternalConns(v2.ActionSConns))
	}
	d.Stir = diffSTIRJsonCfg(d.Stir, v1.STIRCfg, v2.STIRCfg)
	if d.DefaultUsage == nil {
		d.DefaultUsage = make(map[string]string)
	}
	for tor, usage2 := range v2.DefaultUsage {
		if usage1, has := v1.DefaultUsage[tor]; !has || usage1 != usage2 {
			d.DefaultUsage[tor] = usage2.String()
		}
	}
	d.Opts = diffSessionsOptsJsonCfg(d.Opts, v1.Opts, v2.Opts)
	return d
}
