//##############################
// CLASSE WX SEND SMS v5.0 - TÉCNICAS AVANÇADAS WLANGUAGE
// Autor: Adriano - Seguindo Diretivas WX
// Data: 21/06/2025
// Recursos: EvaluateExpression + Indirection + Operadores Ternários
//##############################

// Estrutura avançada com configuração dinâmica
t001_sms_message_v5 is Structure
t001_id is string // ID único da mensagem
t001_phone_number is string // Número de telefone destino
t001_message_text is string // Texto da mensagem
t001_provider_name is string // Nome do provedor
t001_status is string // Status atual
t001_sent_date is DateTime // Data/hora do envio
t001_delivery_date is DateTime // Data/hora da entrega
t001_error_message is string // Mensagem de erro
t001_cost is real // Custo do envio
t001_segments is int // Número de segmentos
t001_priority is int // Prioridade
t001_retry_count is int // Contador de tentativas
t001_external_id is string // ID do provedor externo
t001_queue_id is string // ID da fila
t001_metadata is string // JSON com metadados dinâmicos
t001_validation_rules is string // Regras de validação dinâmicas
t001_routing_expression is string // Expressão para roteamento
END

// Estrutura de configuração dinâmica dos provedores
t002_sms_provider_v5 is Structure
t002_provider_id is string // ID do provedor
t002_provider_name is string // Nome amigável
t002_api_config is string // JSON com configuração da API
t002_validation_expression is string // Expressão de validação
t002_routing_weight is real // Peso para roteamento (0.0-1.0)
t002_is_active is boolean // Provedor ativo
t002_priority_expression is string // Expressão para calcular prioridade
t002_cost_formula is string // Fórmula para calcular custo
t002_rate_limit_config is string // Configuração de rate limiting
t002_failover_rules is string // Regras de failover
t002_dynamic_headers is string // Headers dinâmicos (JSON)
t002_response_parser is string // Parser de resposta customizado
END

// Estrutura de resposta avançada
t003_sms_response_v5 is Structure
t003_success is boolean // Sucesso da operação
t003_message_id is string // ID da mensagem
t003_external_id is string // ID do provedor
t003_status is string // Status retornado
t003_error_code is string // Código de erro
t003_error_message is string // Mensagem de erro
t003_cost is real // Custo calculado
t003_segments is int // Segmentos utilizados
t003_provider_used is string // Provedor utilizado
t003_response_time is int // Tempo de resposta em ms
t003_metadata is string // Metadados da resposta (JSON)
t003_routing_decision is string // Decisão de roteamento tomada
t003_validation_results is string // Resultados das validações
END

// Classe principal SMS v5 com técnicas avançadas
ClasseWxSendSMS_v5 is Class
// Propriedades privadas usando arrays associativos para flexibilidade
m_providers is associative array of t002_sms_provider_v5 // Provedores indexados por ID
m_config_cache is associative array of string // Cache de configurações
m_validation_cache is associative array of boolean // Cache de validações
m_routing_rules is associative array of string // Regras de roteamento
m_dynamic_properties is associative array of Variant // Propriedades dinâmicas
m_expression_cache is associative array of Variant // Cache de expressões avaliadas

// Configurações avançadas
m_debug_mode is boolean = False
m_auto_failover is boolean = True
m_smart_routing is boolean = True
m_cache_enabled is boolean = True
m_expression_timeout is int = 5000 // Timeout para expressões (ms)

// Constantes avançadas usando operadores ternários
CONSTANT
SMS_STATUS_PENDING = "PENDING"
SMS_STATUS_SENT = "SENT"
SMS_STATUS_DELIVERED = "DELIVERED"
SMS_STATUS_FAILED = "FAILED"

PROVIDER_TWILIO = "TWILIO"
PROVIDER_ZENVIA = "ZENVIA"
PROVIDER_AWS_SNS = "AWS_SNS"
PROVIDER_NEXMO = "NEXMO"
PROVIDER_MESSAGEBIRD = "MESSAGEBIRD"
PROVIDER_CLICKSEND = "CLICKSEND"
PROVIDER_PLIVO = "PLIVO"

PRIORITY_CRITICAL = 0
PRIORITY_HIGH = 1
PRIORITY_NORMAL = 2
PRIORITY_LOW = 3
PRIORITY_BULK = 4

ROUTING_ROUND_ROBIN = "ROUND_ROBIN"
ROUTING_COST_OPTIMIZED = "COST_OPTIMIZED"
ROUTING_PERFORMANCE = "PERFORMANCE"
ROUTING_SMART = "SMART"
ROUTING_CUSTOM = "CUSTOM"
END
END

// Construtor avançado com inicialização dinâmica
Procedure Constructor()
// Inicializar propriedades usando operadores ternários
m_debug_mode = (fFileExist(fCurrentDir() + "\debug.flag") ? True : False)
m_auto_failover = (GetEnvironmentVariable("SMS_AUTO_FAILOVER") = "false" ? False : True)
m_smart_routing = (GetEnvironmentVariable("SMS_SMART_ROUTING") = "false" ? False : True)
m_cache_enabled = (GetEnvironmentVariable("SMS_CACHE_ENABLED") = "false" ? False : True)

// Configurar propriedades dinâmicas usando Indirection
{m_dynamic_properties, "log_file"} = fCurrentDir() + "\logs\sms_v5.log"
{m_dynamic_properties, "thread_pool_size"} = 10
{m_dynamic_properties, "max_concurrent_sends"} = 50
{m_dynamic_properties, "retry_delay"} = 2000
{m_dynamic_properties, "default_timeout"} = 30

// Inicializar cache de configurações
InitializeConfigurationCache()

// Carregar provedores usando configuração dinâmica
LoadProvidersFromConfiguration()

// Log de inicialização usando EvaluateExpression
log_message is string = EvaluateExpression([
"ClasseWxSendSMS_v5 inicializada - Debug: " + (m_debug_mode ? "ON" : "OFF") +
", Failover: " + (m_auto_failover ? "ON" : "OFF") +
", Smart Routing: " + (m_smart_routing ? "ON" : "OFF")
])

LogAdvanced(log_message, "INIT")
END

// Procedure para inicializar cache de configurações usando Indirection
Procedure InitializeConfigurationCache()
config_keys is array of string = [
"twilio_base_url", "zenvia_base_url", "aws_sns_region",
"nexmo_base_url", "messagebird_base_url", "clicksend_base_url", "plivo_base_url",
"default_sender_id", "max_message_length", "unicode_support",
"rate_limit_global", "cost_threshold", "performance_threshold"
]

// Usar Indirection para configurar valores padrão
FOR i = 1 TO ArrayCount(config_keys)
config_key is string = config_keys[i]
default_value is string = GetDefaultConfigValue(config_key)

// Indirection para acessar cache dinamicamente
{m_config_cache, config_key} = default_value
END//For

LogAdvanced("Cache de configuração inicializado com " + ArrayCount(config_keys) + " chaves", "CONFIG")
END

// Procedure para obter valor padrão de configuração usando operadores ternários
Procedure GetDefaultConfigValue(config_key is string) : string
// Usar operadores ternários para configurações condicionais
SWITCH config_key
CASE "twilio_base_url"
Result "https://api.twilio.com/2010-04-01/Accounts/"
CASE "zenvia_base_url"
Result "https://api.zenvia.com/v2/channels/sms/messages"
CASE "aws_sns_region"
Result (GetEnvironmentVariable("AWS_REGION") <> "" ? GetEnvironmentVariable("AWS_REGION") : "us-east-1")
CASE "default_sender_id"
Result (GetEnvironmentVariable("SMS_SENDER_ID") <> "" ? GetEnvironmentVariable("SMS_SENDER_ID") : "SMS_SYSTEM")
CASE "max_message_length"
Result "1600" // 10 segmentos padrão
CASE "unicode_support"
Result "true"
CASE "rate_limit_global"
Result "100" // 100 SMS por minuto
CASE "cost_threshold"
Result "0.10" // R$ 0.10 por SMS
CASE "performance_threshold"
Result "2000" // 2 segundos
OTHER CASE
Result ""
END
END

// Procedure para carregar provedores usando configuração dinâmica
Procedure LoadProvidersFromConfiguration()
provider_configs is array of string = [
"TWILIO", "ZENVIA", "AWS_SNS", "NEXMO", "MESSAGEBIRD", "CLICKSEND", "PLIVO"
]

FOR i = 1 TO ArrayCount(provider_configs)
provider_id is string = provider_configs[i]

// Usar EvaluateExpression para verificar se provedor deve ser carregado
should_load is boolean = EvaluateExpression([
GetEnvironmentVariable("SMS_ENABLE_" + provider_id) <> "false" AND
GetEnvironmentVariable("SMS_API_KEY_" + provider_id) <> ""
])

IF should_load
LoadProviderConfiguration(provider_id)
END//If
END//For

LogAdvanced("Provedores carregados: " + ArrayCount(m_providers), "CONFIG")
END

// Procedure para carregar configuração de um provedor específico
Procedure LoadProviderConfiguration(provider_id is string)
provider is t002_sms_provider_v5

// Configuração básica
provider.t002_provider_id = provider_id
provider.t002_provider_name = GetProviderDisplayName(provider_id)

// Usar Indirection para acessar configurações dinamicamente
api_key_env is string = "SMS_API_KEY_" + provider_id
api_secret_env is string = "SMS_API_SECRET_" + provider_id
sender_id_env is string = "SMS_SENDER_ID_" + provider_id

// Configuração da API usando JSON dinâmico
api_config is string = StringBuild([
{
"api_key": "%1",
"api_secret": "%2",
"sender_id": "%3",
"base_url": "%4",
"timeout": %5,
"max_retries": %6
}],
GetEnvironmentVariable(api_key_env),
GetEnvironmentVariable(api_secret_env),
(GetEnvironmentVariable(sender_id_env) <> "" ? GetEnvironmentVariable(sender_id_env) : {m_config_cache, "default_sender_id"}),
{m_config_cache, Lower(provider_id) + "_base_url"},
30,
3)

provider.t002_api_config = api_config

// Expressões dinâmicas usando EvaluateExpression
provider.t002_validation_expression = GetProviderValidationExpression(provider_id)
provider.t002_priority_expression = GetProviderPriorityExpression(provider_id)
provider.t002_cost_formula = GetProviderCostFormula(provider_id)

// Configurações avançadas
provider.t002_routing_weight = GetProviderRoutingWeight(provider_id)
provider.t002_is_active = True
provider.t002_rate_limit_config = GetProviderRateLimitConfig(provider_id)
provider.t002_failover_rules = GetProviderFailoverRules(provider_id)

// Adicionar ao array associativo usando Indirection
{m_providers, provider_id} = provider

LogAdvanced("Provedor " + provider_id + " configurado com sucesso", "CONFIG")
END

// Procedure para obter nome de exibição do provedor usando operadores ternários
Procedure GetProviderDisplayName(provider_id is string) : string
Result (provider_id = "TWILIO" ? "Twilio SMS" :
(provider_id = "ZENVIA" ? "Zenvia Brasil" :
(provider_id = "AWS_SNS" ? "Amazon SNS" :
(provider_id = "NEXMO" ? "Vonage (Nexmo)" :
(provider_id = "MESSAGEBIRD" ? "MessageBird" :
(provider_id = "CLICKSEND" ? "ClickSend" :
(provider_id = "PLIVO" ? "Plivo SMS" : provider_id)))))))
END

// Procedure para obter expressão de validação do provedor
Procedure GetProviderValidationExpression(provider_id is string) : string
// Expressões customizadas por provedor usando EvaluateExpression
SWITCH provider_id
CASE "TWILIO"
Result [Length(phone_number) >= 10 AND Left(phone_number, 1) = "+" AND Length(message_text) <= 1600]
CASE "ZENVIA"
Result [MatchRegularExpression(phone_number, "^\\+55[0-9]{10,11}$") AND Length(message_text) <= 4096]
CASE "AWS_SNS"
Result [Length(phone_number) >= 10 AND Length(message_text) <= 1600]
OTHER CASE
Result [Length(phone_number) >= 10 AND Length(message_text) <= 1600 AND Length(message_text) > 0]
END
END

// Procedure para obter expressão de prioridade do provedor
Procedure GetProviderPriorityExpression(provider_id is string) : string
// Prioridade dinâmica baseada em performance e custo
SWITCH provider_id
CASE "TWILIO"
Result [(response_time < 1000 ? 1 : 2) + (cost < 0.01 ? 0 : 1)]
CASE "ZENVIA"
Result [(response_time < 2000 ? 1 : 3) + (cost < 0.05 ? 0 : 2)]
OTHER CASE
Result [2 + (response_time > 3000 ? 2 : 0) + (cost > 0.02 ? 1 : 0)]
END
END

// Procedure para obter fórmula de custo do provedor
Procedure GetProviderCostFormula(provider_id is string) : string
// Fórmulas de custo dinâmicas
SWITCH provider_id
CASE "TWILIO"
Result [segments * 0.0075 * (priority = 0 ? 1.5 : 1.0)]
CASE "ZENVIA"
Result [segments * 0.05 * (Length(message_text) > 160 ? 1.2 : 1.0)]
CASE "AWS_SNS"
Result [segments * 0.006 * (region = "us-east-1" ? 1.0 : 1.1)]
OTHER CASE
Result [segments * 0.01]
END
END

// Procedure para obter peso de roteamento usando operadores ternários
Procedure GetProviderRoutingWeight(provider_id is string) : real
// Pesos baseados em confiabilidade e performance
Result (provider_id = "TWILIO" ? 0.9 :
(provider_id = "ZENVIA" ? 0.8 :
(provider_id = "AWS_SNS" ? 0.85 :
(provider_id = "NEXMO" ? 0.75 :
(provider_id = "MESSAGEBIRD" ? 0.7 :
(provider_id = "CLICKSEND" ? 0.65 :
(provider_id = "PLIVO" ? 0.7 : 0.5)))))))
END

// Procedure para configuração de rate limiting
Procedure GetProviderRateLimitConfig(provider_id is string) : string
// Configuração JSON para rate limiting
SWITCH provider_id
CASE "TWILIO"
Result [{"requests_per_second": 10, "burst_limit": 50, "window_size": 60}]
CASE "ZENVIA"
Result [{"requests_per_second": 5, "burst_limit": 25, "window_size": 60}]
OTHER CASE
Result [{"requests_per_second": 3, "burst_limit": 15, "window_size": 60}]
END
END

// Procedure para regras de failover
Procedure GetProviderFailoverRules(provider_id is string) : string
// Regras de failover em JSON
Result StringBuild([
{
"max_consecutive_failures": %1,
"failure_window_minutes": %2,
"recovery_test_interval": %3,
"fallback_providers": %4
}],
(provider_id = "TWILIO" ? 3 : 5),
(provider_id = "ZENVIA" ? 10 : 15),
(provider_id = "AWS_SNS" ? 5 : 10),
GetFallbackProviders(provider_id))
END

// Procedure para obter provedores de fallback
Procedure GetFallbackProviders(provider_id is string) : string
// Lista de fallback baseada no provedor principal
SWITCH provider_id
CASE "TWILIO"
Result [["ZENVIA", "AWS_SNS", "NEXMO"]]
CASE "ZENVIA"
Result [["TWILIO", "PLIVO", "CLICKSEND"]]
CASE "AWS_SNS"
Result [["TWILIO", "MESSAGEBIRD", "NEXMO"]]
OTHER CASE
Result [["TWILIO", "ZENVIA"]]
END
END

// Procedure de log avançado usando Indirection
Procedure LogAdvanced(message is string, level is string = "INFO")
timestamp is string = DateTimeToString(DateTimeSys(), "YYYY-MM-DD HH:MM:SS.CCC")
log_entry is string = StringBuild("[%1] [%2] %3", timestamp, level, message)

// Usar Indirection para acessar arquivo de log dinamicamente
log_file is string = {m_dynamic_properties, "log_file"}

// Escrever no arquivo usando operador ternário para verificação
(fDirectoryExist(fExtractPath(log_file)) ? True : fMakeDir(fExtractPath(log_file)))
fWriteLine(log_file, log_entry)

// Debug usando operador ternário
(m_debug_mode ? Trace(log_entry) : Null)
END

// Procedure para configurar propriedade dinâmica usando Indirection
Procedure SetDynamicProperty(property_name is string, property_value is Variant)
// Usar Indirection para acesso dinâmico
{m_dynamic_properties, property_name} = property_value

LogAdvanced(StringBuild("Propriedade dinâmica '%1' configurada", property_name), "CONFIG")
END

// Procedure para obter propriedade dinâmica usando Indirection
Procedure GetDynamicProperty(property_name is string, default_value is Variant = Null) : Variant
// Usar operador ternário com Indirection
Result ({m_dynamic_properties, property_name} <> Null ? {m_dynamic_properties, property_name} : default_value)
END

// Procedure para validação avançada usando EvaluateExpression
Procedure ValidateMessageAdvanced(phone_number is string, message_text is string, provider_id is string = "") : boolean
// Cache de validação usando Indirection
cache_key is string = MD5(phone_number + "|" + message_text + "|" + provider_id)

// Verificar cache primeiro usando operador ternário
IF m_cache_enabled AND {m_validation_cache, cache_key} <> Null
Result {m_validation_cache, cache_key}
END//If

// Validação básica usando EvaluateExpression
basic_validation is string = [
Length(Trim(phone_number)) >= 10 AND
Length(Trim(message_text)) > 0 AND
Length(message_text) <= 4096 AND
MatchRegularExpression(phone_number, "^\\+?[0-9\\s\\-\\(\\)]+$")
]

is_valid is boolean = EvaluateExpression(basic_validation)

// Validação específica do provedor se especificado
IF is_valid AND provider_id <> "" AND {m_providers, provider_id} <> Null
provider_validation is string = {m_providers, provider_id}.t002_validation_expression

// Substituir variáveis na expressão
provider_validation = Replace(provider_validation, "phone_number", "\"" + phone_number + "\"")
provider_validation = Replace(provider_validation, "message_text", "\"" + message_text + "\"")

is_valid = is_valid AND EvaluateExpression(provider_validation)
END//If

// Armazenar no cache usando Indirection
IF m_cache_enabled
{m_validation_cache, cache_key} = is_valid
END//If

Result is_valid
END

//Final do Arquivo

//##############################
// CLASSE WX SEND SMS v5.0 - SISTEMA DE THREADS AVANÇADO
// Threads inteligentes com operadores ternários e EvaluateExpression
// Pool dinâmico, balanceamento automático e monitoramento em tempo real
//##############################

// Estrutura avançada de controle de threads
t004_thread_control_v5 is Structure
t004_thread_id is string // ID único da thread
t004_thread_status is string // Status usando operadores ternários
t004_messages_assigned is int // Mensagens atribuídas
t004_messages_processed is int // Mensagens processadas
t004_messages_success is int // Sucessos
t004_messages_failed is int // Falhas
t004_start_time is DateTime // Início do processamento
t004_last_activity is DateTime // Última atividade
t004_current_provider is string // Provedor atual
t004_performance_score is real // Score de performance (0.0-1.0)
t004_error_rate is real // Taxa de erro (0.0-1.0)
t004_avg_response_time is real // Tempo médio de resposta
t004_priority_level is int // Nível de prioridade da thread
t004_load_factor is real // Fator de carga atual
t004_dynamic_config is string // Configuração dinâmica (JSON)
END

// Estrutura de fila inteligente
t005_smart_queue_v5 is Structure
t005_queue_id is string // ID da fila
t005_queue_name is string // Nome amigável
t005_messages is array of t001_sms_message_v5 // Array de mensagens
t005_priority_expression is string // Expressão para calcular prioridade
t005_routing_strategy is string // Estratégia de roteamento
t005_created_date is DateTime // Data de criação
t005_status is string // Status da fila
t005_total_messages is int // Total de mensagens
t005_processed_messages is int // Mensagens processadas
t005_estimated_completion is DateTime // Estimativa de conclusão
t005_performance_metrics is string // Métricas de performance (JSON)
t005_auto_scaling_config is string // Configuração de auto-scaling
END

// Propriedades avançadas para controle de threads
m_thread_pool_v5 is associative array of t004_thread_control_v5 // Pool usando Indirection
m_smart_queues is associative array of t005_smart_queue_v5 // Filas inteligentes
m_thread_performance is associative array of real // Performance por thread
m_load_balancer_config is associative array of Variant // Configuração do balanceador
m_auto_scaling_enabled is boolean = True // Auto-scaling ativo
m_max_threads_dynamic is int = 15 // Máximo dinâmico de threads
m_min_threads is int = 2 // Mínimo de threads
m_target_load_per_thread is real = 0.8 // Carga alvo por thread
m_performance_threshold is real = 0.7 // Threshold de performance

// Procedure para envio em lote inteligente usando operadores ternários
Procedure SendSMSBatchSmart(phone_numbers is array of string, message_text is string, priority is int = PRIORITY_NORMAL, routing_strategy is string = ROUTING_SMART) : string
queue_id is string
smart_queue is t005_smart_queue_v5

// Validação usando operadores ternários
IF (ArrayCount(phone_numbers) = 0 ? True : Length(Trim(message_text)) = 0)
LogAdvanced("Parâmetros inválidos para envio em lote", "ERROR")
Result ""
END//If

// Gerar ID único usando operador ternário
queue_id = "SMART_" + (priority = PRIORITY_CRITICAL ? "CRIT_" :
(priority = PRIORITY_HIGH ? "HIGH_" :
(priority = PRIORITY_LOW ? "LOW_" : "NORM_"))) +
DateToString(DateSys(), "YYYYMMDD") + "_" + TimeToString(TimeSys(), "HHMMSSCC")

// Configurar fila inteligente
smart_queue.t005_queue_id = queue_id
smart_queue.t005_queue_name = "Lote " + ArrayCount(phone_numbers) + " mensagens"
smart_queue.t005_routing_strategy = routing_strategy
smart_queue.t005_created_date = DateTimeSys()
smart_queue.t005_status = "PREPARING"
smart_queue.t005_total_messages = ArrayCount(phone_numbers)
smart_queue.t005_processed_messages = 0

// Expressão de prioridade dinâmica usando EvaluateExpression
smart_queue.t005_priority_expression = StringBuild([
base_priority + (message_count > 1000 ? 2 : 0) + (estimated_cost > 100 ? 1 : 0)
], priority)

// Preparar mensagens individuais com otimizações
PrepareMessagesForQueue(smart_queue, phone_numbers, message_text, priority)

// Calcular estimativa de conclusão usando EvaluateExpression
estimated_duration is real = CalculateEstimatedDuration(smart_queue)
smart_queue.t005_estimated_completion = DateTimeAdd(DateTimeSys(), estimated_duration, duSecond)

// Configurar auto-scaling usando operadores ternários
auto_scaling_config is string = StringBuild([
{
"enabled": %1,
"min_threads": %2,
"max_threads": %3,
"scale_up_threshold": %4,
"scale_down_threshold": %5,
"scale_factor": %6
}], (m_auto_scaling_enabled ? "true" : "false"),
m_min_threads,
(ArrayCount(phone_numbers) > 5000 ? m_max_threads_dynamic * 2 : m_max_threads_dynamic),
0.8,
0.3,
1.5)

smart_queue.t005_auto_scaling_config = auto_scaling_config

// Adicionar à lista de filas usando Indirection
{m_smart_queues, queue_id} = smart_queue

LogAdvanced(StringBuild("Fila inteligente %1 criada com %2 mensagens, estratégia: %3",
queue_id, ArrayCount(phone_numbers), routing_strategy), "QUEUE")

// Iniciar processamento inteligente
StartSmartProcessing(queue_id)

Result queue_id
END

// Procedure para preparar mensagens para a fila
Procedure PrepareMessagesForQueue(smart_queue is t005_smart_queue_v5, phone_numbers is array of string, message_text is string, priority is int)
message is t001_sms_message_v5

FOR i = 1 TO ArrayCount(phone_numbers)
// Configurar mensagem básica
message.t001_id = GenerateMessageID()
message.t001_phone_number = phone_numbers[i]
message.t001_message_text = message_text
message.t001_priority = priority
message.t001_status = SMS_STATUS_PENDING
message.t001_sent_date = DateTimeSys()
message.t001_segments = CalculateSMSSegments(message_text)
message.t001_retry_count = 0
message.t001_queue_id = smart_queue.t005_queue_id

// Configuração avançada usando operadores ternários
message.t001_validation_rules = (priority = PRIORITY_CRITICAL ? "strict" : "standard")

// Roteamento inteligente usando EvaluateExpression
routing_hint is string = DetermineOptimalProvider(phone_numbers[i], message_text, priority)
message.t001_routing_expression = StringBuild([
provider_score > 0.8 AND response_time < 2000 AND cost < %1
], (priority = PRIORITY_CRITICAL ? 0.05 : 0.10))

// Metadados dinâmicos
message.t001_metadata = StringBuild([
{
"batch_position": %1,
"batch_total": %2,
"routing_hint": "%3",
"preparation_time": "%4"
}], i, ArrayCount(phone_numbers), routing_hint, DateTimeToString(DateTimeSys()))

ArrayAdd(smart_queue.t005_messages, message)
END//For

LogAdvanced(StringBuild("Preparadas %1 mensagens para fila %2",
ArrayCount(smart_queue.t005_messages), smart_queue.t005_queue_id), "PREP")
END

// Procedure para iniciar processamento inteligente
Procedure StartSmartProcessing(queue_id is string)
// Verificar se fila existe usando Indirection
IF {m_smart_queues, queue_id} = Null
LogAdvanced("Fila não encontrada: " + queue_id, "ERROR")
Return
END//If

smart_queue is t005_smart_queue_v5 = {m_smart_queues, queue_id}

// Calcular número ótimo de threads usando EvaluateExpression
optimal_threads is int = CalculateOptimalThreadCount(smart_queue)

// Atualizar status da fila
{m_smart_queues, queue_id}.t005_status = "PROCESSING"

LogAdvanced(StringBuild("Iniciando processamento inteligente: %1 threads para fila %2",
optimal_threads, queue_id), "PROCESSING")

// Criar threads inteligentes
CreateSmartThreads(queue_id, optimal_threads)

// Iniciar monitoramento em background
StartQueueMonitoring(queue_id)
END

// Procedure para calcular número ótimo de threads usando EvaluateExpression
Procedure CalculateOptimalThreadCount(smart_queue is t005_smart_queue_v5) : int
message_count is int = smart_queue.t005_total_messages
priority is int = ExtractPriorityFromQueue(smart_queue)

// Fórmula dinâmica usando EvaluateExpression
base_formula is string = StringBuild([
Min(%1, Max(%2, Ceiling(message_count / %3) * %4))
], m_max_threads_dynamic,
m_min_threads,
(priority = PRIORITY_CRITICAL ? 50 : 100),
(priority = PRIORITY_CRITICAL ? 2.0 : 1.0))

// Substituir variáveis
formula_with_values is string = Replace(base_formula, "message_count", message_count)

optimal_count is int = EvaluateExpression(formula_with_values)

// Ajustar baseado na carga atual usando operador ternário
current_load is real = GetCurrentSystemLoad()
adjusted_count is int = (current_load > 0.8 ? optimal_count / 2 : optimal_count)

LogAdvanced(StringBuild("Threads calculadas: %1 (base: %2, carga: %3)",
adjusted_count, optimal_count, current_load), "CALC")

Result adjusted_count
END

// Procedure para criar threads inteligentes
Procedure CreateSmartThreads(queue_id is string, thread_count is int)
smart_queue is t005_smart_queue_v5 = {m_smart_queues, queue_id}
messages_per_thread is int = Ceiling(smart_queue.t005_total_messages / thread_count)

FOR i = 1 TO thread_count
thread_control is t004_thread_control_v5

// Configuração básica da thread
thread_control.t004_thread_id = "SMART_" + queue_id + "_T" + i
thread_control.t004_thread_status = "INITIALIZING"
thread_control.t004_start_time = DateTimeSys()
thread_control.t004_last_activity = DateTimeSys()
thread_control.t004_performance_score = 1.0
thread_control.t004_error_rate = 0.0
thread_control.t004_avg_response_time = 0.0

// Calcular range de mensagens para esta thread
start_index is int = ((i - 1) * messages_per_thread) + 1
end_index is int = Min(i * messages_per_thread, smart_queue.t005_total_messages)
thread_control.t004_messages_assigned = end_index - start_index + 1

// Prioridade da thread usando operador ternário
thread_control.t004_priority_level = (i <= thread_count / 2 ? PRIORITY_HIGH : PRIORITY_NORMAL)

// Configuração dinâmica da thread
thread_config is string = StringBuild([
{
"queue_id": "%1",
"start_index": %2,
"end_index": %3,
"delay_ms": %4,
"retry_limit": %5,
"performance_target": %6
}], queue_id, start_index, end_index,
(thread_control.t004_priority_level = PRIORITY_HIGH ? 100 : 200),
(thread_control.t004_priority_level = PRIORITY_HIGH ? 5 : 3),
0.8)

thread_control.t004_dynamic_config = thread_config

// Adicionar ao pool usando Indirection
{m_thread_pool_v5, thread_control.t004_thread_id} = thread_control

// Executar thread
thread_params is string = thread_control.t004_thread_id + "|" + thread_config
ThreadExecute("ProcessSmartMessageRange", threadNormal, thread_params)

LogAdvanced(StringBuild("Thread inteligente %1 criada: mensagens %2-%3",
thread_control.t004_thread_id, start_index, end_index), "THREAD")
END//For
END

// Procedure principal da thread inteligente (executada em thread separada)
Procedure ProcessSmartMessageRange(params is string)
param_parts is array of string
thread_id is string
config_json is string

// Parse dos parâmetros
StringToArray(params, param_parts, "|")
thread_id = param_parts[1]
config_json = param_parts[2]

// Extrair configuração usando JSONExtractString
queue_id is string = JSONExtractString(config_json, "queue_id")
start_index is int = Val(JSONExtractString(config_json, "start_index"))
end_index is int = Val(JSONExtractString(config_json, "end_index"))
delay_ms is int = Val(JSONExtractString(config_json, "delay_ms"))
retry_limit is int = Val(JSONExtractString(config_json, "retry_limit"))

// Verificar se thread e fila existem usando Indirection
IF {m_thread_pool_v5, thread_id} = Null OR {m_smart_queues, queue_id} = Null
LogAdvanced("Thread ou fila não encontrada: " + thread_id, "ERROR")
Return
END//If

// Atualizar status da thread
{m_thread_pool_v5, thread_id}.t004_thread_status = "RUNNING"

smart_queue is t005_smart_queue_v5 = {m_smart_queues, queue_id}

LogAdvanced(StringBuild("Thread %1 iniciada: processando mensagens %2-%3",
thread_id, start_index, end_index), "THREAD")

// Processar mensagens no range
FOR i = start_index TO end_index
IF i <= ArrayCount(smart_queue.t005_messages)
message is t001_sms_message_v5 = smart_queue.t005_messages[i]

// Atualizar atividade da thread
{m_thread_pool_v5, thread_id}.t004_last_activity = DateTimeSys()

// Processar mensagem com retry inteligente
success is boolean = ProcessMessageWithSmartRetry(message, thread_id, retry_limit)

// Atualizar contadores usando operadores ternários
{m_thread_pool_v5, thread_id}.t004_messages_processed++
(success ? {m_thread_pool_v5, thread_id}.t004_messages_success++ : {m_thread_pool_v5, thread_id}.t004_messages_failed++)

// Atualizar contador global da fila
{m_smart_queues, queue_id}.t005_processed_messages++

// Delay adaptativo usando EvaluateExpression
current_performance is real = CalculateThreadPerformance(thread_id)
adaptive_delay is int = EvaluateExpression([
delay_ms * (current_performance < 0.7 ? 1.5 : 1.0)
])

// Aplicar delay se necessário
IF adaptive_delay > 0
Multitask(adaptive_delay)
END//If

// Verificar se deve parar (cancelamento externo)
IF {m_thread_pool_v5, thread_id}.t004_thread_status = "STOPPING"
BREAK
END//If
END//If
END//For

// Finalizar thread
{m_thread_pool_v5, thread_id}.t004_thread_status = "COMPLETED"

LogAdvanced(StringBuild("Thread %1 concluída: %2 sucessos, %3 falhas",
thread_id,
{m_thread_pool_v5, thread_id}.t004_messages_success,
{m_thread_pool_v5, thread_id}.t004_messages_failed), "THREAD")
END

// Procedure para processar mensagem com retry inteligente
Procedure ProcessMessageWithSmartRetry(message is t001_sms_message_v5, thread_id is string, retry_limit is int) : boolean
response is t003_sms_response_v5
attempt is int = 0
success is boolean = False

WHILE attempt < retry_limit AND NOT success
attempt++

// Selecionar provedor usando roteamento inteligente
provider_id is string = SelectProviderForMessage(message, attempt)

// Atualizar provedor atual da thread
{m_thread_pool_v5, thread_id}.t004_current_provider = provider_id

// Tentar envio
start_time is int = GetTickCount()
response = SendSMSWithProvider(message.t001_phone_number, message.t001_message_text, message.t001_priority, provider_id)
response_time is int = GetTickCount() - start_time

success = response.t003_success

// Atualizar performance da thread usando EvaluateExpression
UpdateThreadPerformance(thread_id, success, response_time)

// Log da tentativa usando operador ternário
LogAdvanced(StringBuild("Thread %1, tentativa %2/%3: %4 - %5",
thread_id, attempt, retry_limit,
(success ? "SUCESSO" : "FALHA"),
(success ? response.t003_external_id : response.t003_error_message)), "RETRY")

// Delay entre tentativas usando operador ternário (backoff exponencial)
IF NOT success AND attempt < retry_limit
backoff_delay is int = (attempt * attempt * 1000) // 1s, 4s, 9s, 16s...
Multitask(backoff_delay)
END//If
END//While

// Atualizar contador de retry da mensagem
message.t001_retry_count = attempt
message.t001_status = (success ? SMS_STATUS_SENT : SMS_STATUS_FAILED)

Result success
END

// Procedure para selecionar provedor para mensagem específica
Procedure SelectProviderForMessage(message is t001_sms_message_v5, attempt is int) : string
// Usar roteamento baseado na tentativa usando operador ternário
IF attempt = 1
// Primeira tentativa: usar roteamento normal
Result SelectOptimalProvider(message.t001_phone_number, message.t001_message_text, message.t001_priority)
ELSE
// Tentativas subsequentes: evitar provedores que falharam
Result SelectAlternativeProvider(message.t001_phone_number, message.t001_priority, attempt)
END//If
END

// Procedure para selecionar provedor alternativo
Procedure SelectAlternativeProvider(phone_number is string, priority is int, attempt is int) : string
// Lista de provedores ordenada por confiabilidade
reliable_providers is array of string = [PROVIDER_TWILIO, PROVIDER_ZENVIA, PROVIDER_NEXMO, PROVIDER_PLIVO]

// Selecionar baseado na tentativa usando operador ternário
provider_index is int = (attempt - 1) % ArrayCount(reliable_providers) + 1
selected_provider is string = reliable_providers[provider_index]

// Verificar se provedor está ativo usando Indirection
IF {m_providers, selected_provider} <> Null AND {m_providers, selected_provider}.t002_is_active
Result selected_provider
ELSE
// Fallback para primeiro provedor ativo
Result GetFirstActiveProvider()
END//If
END

// Procedure para atualizar performance da thread
Procedure UpdateThreadPerformance(thread_id is string, success is boolean, response_time is int)
// Obter dados atuais usando Indirection
current_score is real = {m_thread_pool_v5, thread_id}.t004_performance_score
current_avg_time is real = {m_thread_pool_v5, thread_id}.t004_avg_response_time
processed_count is int = {m_thread_pool_v5, thread_id}.t004_messages_processed

// Calcular nova performance usando EvaluateExpression
success_factor is real = (success ? 1.0 : 0.0)
time_factor is real = EvaluateExpression([1.0 - Min(response_time / 5000, 1.0)]) // Normalizar por 5s

new_score is real = EvaluateExpression([
(current_score * 0.8) + ((success_factor * 0.6 + time_factor * 0.4) * 0.2)
])

// Calcular nova média de tempo
new_avg_time is real = (processed_count = 0 ? response_time :
EvaluateExpression([(current_avg_time * processed_count + response_time) / (processed_count + 1)]))

// Atualizar usando Indirection
{m_thread_pool_v5, thread_id}.t004_performance_score = new_score
{m_thread_pool_v5, thread_id}.t004_avg_response_time = new_avg_time

// Calcular taxa de erro
failed_count is int = {m_thread_pool_v5, thread_id}.t004_messages_failed
total_processed is int = {m_thread_pool_v5, thread_id}.t004_messages_processed + 1
error_rate is real = (total_processed > 0 ? failed_count / total_processed : 0.0)
{m_thread_pool_v5, thread_id}.t004_error_rate = error_rate
END

// Procedure para calcular performance atual da thread
Procedure CalculateThreadPerformance(thread_id is string) : real
// Usar Indirection para acessar dados da thread
Result ({m_thread_pool_v5, thread_id} <> Null ? {m_thread_pool_v5, thread_id}.t004_performance_score : 0.0)
END

// Procedure para obter carga atual do sistema
Procedure GetCurrentSystemLoad() : real
active_threads is int = 0
total_load is real = 0.0

// Contar threads ativas e calcular carga usando Indirection
FOR EACH thread_id, thread_control OF m_thread_pool_v5
IF thread_control.t004_thread_status = "RUNNING"
active_threads++
total_load += thread_control.t004_load_factor
END//If
END//For

// Calcular carga média usando operador ternário
Result (active_threads > 0 ? total_load / active_threads : 0.0)
END

// Procedure para monitoramento de fila em background
Procedure StartQueueMonitoring(queue_id is string)
// Executar monitoramento em thread separada
ThreadExecute("MonitorQueueProgress", threadNormal, queue_id)

LogAdvanced("Monitoramento iniciado para fila: " + queue_id, "MONITOR")
END

// Procedure de monitoramento (executada em thread)
Procedure MonitorQueueProgress(queue_id is string)
monitoring_active is boolean = True
check_interval is int = 5000 // 5 segundos

WHILE monitoring_active
// Verificar se fila ainda existe usando Indirection
IF {m_smart_queues, queue_id} = Null
BREAK
END//If

smart_queue is t005_smart_queue_v5 = {m_smart_queues, queue_id}

// Verificar se processamento foi concluído
IF smart_queue.t005_processed_messages >= smart_queue.t005_total_messages
{m_smart_queues, queue_id}.t005_status = "COMPLETED"
monitoring_active = False

LogAdvanced(StringBuild("Fila %1 concluída: %2/%3 mensagens processadas",
queue_id, smart_queue.t005_processed_messages, smart_queue.t005_total_messages), "MONITOR")
ELSE
// Calcular progresso usando operador ternário
progress_percent is real = (smart_queue.t005_total_messages > 0 ?
(smart_queue.t005_processed_messages * 100.0) / smart_queue.t005_total_messages : 0.0)

LogAdvanced(StringBuild("Fila %1: %2%% concluída (%3/%4)",
queue_id, progress_percent, smart_queue.t005_processed_messages, smart_queue.t005_total_messages), "PROGRESS")
END//If

// Aguardar próxima verificação
Multitask(check_interval)
END//While

LogAdvanced("Monitoramento finalizado para fila: " + queue_id, "MONITOR")
END

//Final do Arquivo

//##############################
// CLASSE WX SEND SMS v5.0 - EXEMPLOS AVANÇADOS
// Demonstrações completas de EvaluateExpression, Indirection e Operadores Ternários
// Casos de uso reais e testes das técnicas modernas WLanguage
//##############################

// Procedure principal de demonstração das técnicas avançadas
Procedure ExemploCompletoTecnicasAvancadas()
sms_system is ClasseWxSendSMS_v5

Info("=== DEMONSTRAÇÃO TÉCNICAS AVANÇADAS WLanguage v5.0 ===")

// Inicializar sistema avançado
IF NOT sms_system.InitializeDatabaseAdvanced()
Error("Falha ao inicializar sistema avançado!")
Return
END//If

// Configurar modo debug usando operador ternário
debug_enabled is boolean = (fFileExist(fCurrentDir() + "\debug.flag") ? True : False)
sms_system.SetDynamicProperty("debug_mode", debug_enabled)

Info("🚀 Sistema inicializado - Debug: " + (debug_enabled ? "ATIVO" : "INATIVO"))

// Demonstrações das técnicas
Info("--- 1. EvaluateExpression ---")
ExemploEvaluateExpression(sms_system)

Info("--- 2. Indirection ---")
ExemploIndirection(sms_system)

Info("--- 3. Operadores Ternários ---")
ExemploOperadoresTernarios(sms_system)

Info("--- 4. Roteamento Inteligente ---")
ExemploRoteamentoInteligente(sms_system)

Info("--- 5. Cache Dinâmico ---")
ExemploCacheDinamico(sms_system)

Info("--- 6. Analytics em Tempo Real ---")
ExemploAnalyticsTempoReal(sms_system)

Info("--- 7. Threads Inteligentes ---")
ExemploThreadsInteligentes(sms_system)

Info("=== DEMONSTRAÇÃO CONCLUÍDA ===")
END

// Exemplo 1: EvaluateExpression para validações e cálculos dinâmicos
Procedure ExemploEvaluateExpression(sms_system is ClasseWxSendSMS_v5)
Info("🧮 Demonstrando EvaluateExpression...")

// Exemplo 1.1: Validação dinâmica de números
phone_numbers is array of string = ["+5511999999999", "11888888888", "+1234567890", "invalid"]

FOR i = 1 TO ArrayCount(phone_numbers)
phone is string = phone_numbers[i]

// Expressão de validação dinâmica usando EvaluateExpression
validation_expression is string = StringBuild([
Length(phone) >= 10 AND
(Left(phone, 1) = "+" OR IsNumeric(Left(phone, 1))) AND
MatchRegularExpression(phone, "^[\\+]?[0-9\\s\\-\\(\\)]+$")
])

// Substituir variável na expressão
validation_with_value is string = Replace(validation_expression, "phone", "\"" + phone + "\"")

is_valid is boolean = EvaluateExpression(validation_with_value)

Info(StringBuild("📱 %1: %2", phone, (is_valid ? "✅ VÁLIDO" : "❌ INVÁLIDO")))
END//For

// Exemplo 1.2: Cálculo dinâmico de custo
message_text is string = "Esta é uma mensagem de teste para demonstrar o cálculo dinâmico de custo usando EvaluateExpression! 🚀📱💰"
segments is int = sms_system.CalculateSMSSegments(message_text)
priority is int = PRIORITY_HIGH

// Fórmula de custo dinâmica
cost_formula is string = StringBuild([
(segments * 0.05) * (priority = 1 ? 1.5 : 1.0) * (segments > 1 ? 1.2 : 1.0)
])

calculated_cost is real = EvaluateExpression(cost_formula)

Info(StringBuild("💰 Custo calculado dinamicamente: R$ %1 (%2 segmentos, prioridade %3)",
NumToString(calculated_cost, "0.0000"), segments, priority))

// Exemplo 1.3: Seleção de provedor baseada em expressão
providers_data is array of string = ["TWILIO:0.9:200", "ZENVIA:0.8:300", "NEXMO:0.7:250"]
best_provider is string = ""
best_score is real = -1

FOR i = 1 TO ArrayCount(providers_data)
provider_info is array of string
StringToArray(providers_data[i], provider_info, ":")

provider_name is string = provider_info[1]
reliability is real = Val(provider_info[2])
avg_time is real = Val(provider_info[3])

// Score usando EvaluateExpression
score_expression is string = StringBuild([
(reliability * 0.6) + ((1000 - Min(avg_time, 1000)) / 1000 * 0.4)
])

provider_score is real = EvaluateExpression(score_expression)

IF provider_score > best_score
best_provider = provider_name
best_score = provider_score
END//If

Info(StringBuild("🏆 %1: Score %2 (confiabilidade: %3, tempo: %4ms)",
provider_name, NumToString(provider_score, "0.000"), reliability, avg_time))
END//For

Info(StringBuild("🥇 Melhor provedor selecionado: %1 (score: %2)", best_provider, NumToString(best_score, "0.000")))
END

// Exemplo 2: Indirection para acesso dinâmico a propriedades
Procedure ExemploIndirection(sms_system is ClasseWxSendSMS_v5)
Info("🔗 Demonstrando Indirection...")

// Exemplo 2.1: Configuração dinâmica de propriedades
config_properties is array of string = [
"max_threads:15",
"retry_delay:2000",
"cache_timeout:3600",
"debug_level:2",
"rate_limit:100"
]

Info("⚙️ Configurando propriedades dinamicamente:")
FOR i = 1 TO ArrayCount(config_properties)
property_parts is array of string
StringToArray(config_properties[i], property_parts, ":")

property_name is string = property_parts[1]
property_value is string = property_parts[2]

// Usar Indirection para definir propriedade dinamicamente
sms_system.SetDynamicProperty(property_name, property_value)

Info(StringBuild(" %1 = %2", property_name, property_value))
END//For

// Exemplo 2.2: Acesso dinâmico a configurações
Info("📖 Lendo propriedades dinamicamente:")
property_names is array of string = ["max_threads", "retry_delay", "cache_timeout", "unknown_property"]

FOR i = 1 TO ArrayCount(property_names)
prop_name is string = property_names[i]

// Usar Indirection para acessar propriedade dinamicamente
prop_value is Variant = sms_system.GetDynamicProperty(prop_name, "NÃO ENCONTRADO")

Info(StringBuild(" %1 = %2", prop_name, prop_value))
END//For

// Exemplo 2.3: Cache dinâmico usando Indirection
cache_data is associative array of string
cache_keys is array of string = ["user_preferences", "provider_stats", "routing_cache", "validation_cache"]

Info("💾 Demonstrando cache dinâmico:")
FOR i = 1 TO ArrayCount(cache_keys)
cache_key is string = cache_keys[i]
cache_value is string = StringBuild("Dados para %1 - %2", cache_key, DateTimeToString(DateTimeSys()))

// Usar Indirection para armazenar no cache
{cache_data, cache_key} = cache_value

Info(StringBuild(" Cache[%1] = %2", cache_key, Left(cache_value, 30) + "..."))
END//For

// Acessar cache dinamicamente
Info("🔍 Acessando cache dinamicamente:")
FOR i = 1 TO ArrayCount(cache_keys)
cache_key is string = cache_keys[i]

// Usar Indirection para recuperar do cache
cached_value is string = {cache_data, cache_key}

Info(StringBuild(" Recuperado[%1] = %2", cache_key, (Length(cached_value) > 0 ? "✅ ENCONTRADO" : "❌ VAZIO")))
END//For

// Exemplo 2.4: Estatísticas dinâmicas por provedor
provider_stats is associative array of string
providers is array of string = ["TWILIO", "ZENVIA", "NEXMO"]

Info("📊 Gerando estatísticas dinâmicas:")
FOR i = 1 TO ArrayCount(providers)
provider_id is string = providers[i]

// Gerar estatísticas simuladas
total_sent is int = Random(100, 1000)
success_rate is real = Random(85, 99) / 100.0
avg_cost is real = Random(3, 8) / 100.0

stats_json is string = StringBuild([
{
"total_sent": %1,
"success_rate": %2,
"avg_cost": %3,
"last_updated": "%4"
}], total_sent, success_rate, avg_cost, DateTimeToString(DateTimeSys()))

// Usar Indirection para armazenar estatísticas
{provider_stats, provider_id} = stats_json

Info(StringBuild(" %1: %2 enviados, %3%% sucesso, R$ %4 médio",
provider_id, total_sent, NumToString(success_rate * 100, "0.0"), NumToString(avg_cost, "0.000")))
END//For
END

// Exemplo 3: Operadores Ternários para lógica condicional elegante
Procedure ExemploOperadoresTernarios(sms_system is ClasseWxSendSMS_v5)
Info("❓ Demonstrando Operadores Ternários...")

// Exemplo 3.1: Classificação de mensagens
messages_data is array of string = [
"Olá!:1:50",
"Esta é uma mensagem muito longa que vai precisar de múltiplos segmentos para ser enviada completamente.:2:180",
"URGENTE - Ação necessária imediatamente!:0:25",
"Promoção especial válida até amanhã.:3:90"
]

Info("📝 Classificando mensagens com operadores ternários:")
FOR i = 1 TO ArrayCount(messages_data)
msg_parts is array of string
StringToArray(messages_data[i], msg_parts, ":")

message_text is string = msg_parts[1]
priority is int = Val(msg_parts[2])
length is int = Val(msg_parts[3])

// Classificações usando operadores ternários aninhados
priority_label is string = (priority = 0 ? "🔴 CRÍTICA" :
(priority = 1 ? "🟡 ALTA" :
(priority = 2 ? "🟢 NORMAL" : "🔵 BAIXA")))

length_category is string = (length <= 50 ? "📏 CURTA" :
(length <= 160 ? "📐 MÉDIA" : "📏 LONGA"))

urgency_factor is real = (priority = 0 ? 2.0 :
(priority = 1 ? 1.5 :
(priority = 2 ? 1.0 : 0.8)))

estimated_cost is real = (length <= 160 ? 0.05 : 0.05 * Ceiling(length / 160.0)) * urgency_factor

delivery_time is string = (priority = 0 ? "⚡ IMEDIATO" :
(priority = 1 ? "🚀 RÁPIDO" :
(priority = 2 ? "⏰ NORMAL" : "🐌 QUANDO POSSÍVEL")))

Info(StringBuild(" %1 | %2 | %3 | R$ %4 | %5",
priority_label, length_category, delivery_time,
NumToString(estimated_cost, "0.000"), Left(message_text, 30) + "..."))
END//For

// Exemplo 3.2: Seleção de estratégia de envio
scenarios is array of string = [
"1000:0:WEEKEND", // 1000 mensagens, prioridade crítica, fim de semana
"50:2:BUSINESS_HOURS", // 50 mensagens, prioridade normal, horário comercial
"5000:1:NIGHT", // 5000 mensagens, prioridade alta, noite
"10:0:HOLIDAY" // 10 mensagens, prioridade crítica, feriado
]

Info("🎯 Selecionando estratégias de envio:")
FOR i = 1 TO ArrayCount(scenarios)
scenario_parts is array of string
StringToArray(scenarios[i], scenario_parts, ":")

message_count is int = Val(scenario_parts[1])
priority is int = Val(scenario_parts[2])
time_context is string = scenario_parts[3]

// Estratégia usando operadores ternários complexos
thread_count is int = (message_count > 1000 ?
(priority = 0 ? 15 : 10) :
(message_count > 100 ?
(priority = 0 ? 8 : 5) :
(priority = 0 ? 3 : 2)))

delay_ms is int = (time_context = "BUSINESS_HOURS" ?
(priority = 0 ? 100 : 500) :
(time_context = "NIGHT" ?
(priority = 0 ? 200 : 1000) :
(priority = 0 ? 50 : 300)))

provider_strategy is string = (priority = 0 ? "PREMIUM_ONLY" :
(message_count > 1000 ? "LOAD_BALANCED" :
(time_context = "WEEKEND" ? "COST_OPTIMIZED" : "STANDARD")))

estimated_duration is int = (message_count * delay_ms) / thread_count / 1000

Info(StringBuild(" 📊 %1 msgs | Prioridade %2 | %3", message_count, priority, time_context))
Info(StringBuild(" → %1 threads | %2ms delay | %3 | ~%4s",
thread_count, delay_ms, provider_strategy, estimated_duration))
END//For

// Exemplo 3.3: Formatação condicional de relatórios
performance_data is array of string = ["TWILIO:95.5:250", "ZENVIA:88.2:380", "NEXMO:92.1:290"]

Info("📈 Formatando relatórios com operadores ternários:")
FOR i = 1 TO ArrayCount(performance_data)
perf_parts is array of string
StringToArray(performance_data[i], perf_parts, ":")

provider is string = perf_parts[1]
success_rate is real = Val(perf_parts[2])
avg_time is real = Val(perf_parts[3])

// Formatação condicional usando operadores ternários
performance_icon is string = (success_rate >= 95 ? "🏆" :
(success_rate >= 90 ? "🥈" :
(success_rate >= 85 ? "🥉" : "⚠️")))

speed_icon is string = (avg_time <= 200 ? "⚡" :
(avg_time <= 300 ? "🚀" :
(avg_time <= 400 ? "⏰" : "🐌")))

status_color is string = (success_rate >= 95 AND avg_time <= 250 ? "🟢 EXCELENTE" :
(success_rate >= 90 AND avg_time <= 350 ? "🟡 BOM" :
(success_rate >= 85 ? "🟠 REGULAR" : "🔴 RUIM")))

recommendation is string = (success_rate >= 95 ? "Usar para mensagens críticas" :
(success_rate >= 90 ? "Usar para envios normais" :
(success_rate >= 85 ? "Usar apenas como backup" : "Desativar temporariamente")))

Info(StringBuild(" %1 %2 %3: %4%% sucesso, %5ms | %6",
performance_icon, speed_icon, provider,
NumToString(success_rate, "0.0"), NumToString(avg_time, "0"), status_color))
Info(StringBuild(" 💡 %1", recommendation))
END//For
END

// Exemplo 4: Roteamento inteligente combinando todas as técnicas
Procedure ExemploRoteamentoInteligente(sms_system is ClasseWxSendSMS_v5)
Info("🧠 Demonstrando Roteamento Inteligente...")

// Configurar provedores simulados
ConfigurarProvedoresSimulados(sms_system)

// Cenários de teste
test_scenarios is array of string = [
"+5511999999999:Mensagem urgente!:0", // Brasil, crítica
"+1234567890:Regular message:2", // EUA, normal
"+5511888888888:Promoção especial hoje!:1", // Brasil, alta
"+4412345678:International test:2" // Reino Unido, normal
]

Info("🎯 Testando roteamento inteligente:")
FOR i = 1 TO ArrayCount(test_scenarios)
scenario_parts is array of string
StringToArray(test_scenarios[i], scenario_parts, ":")

phone_number is string = scenario_parts[1]
message_text is string = scenario_parts[2]
priority is int = Val(scenario_parts[3])

// Análise do número usando operadores ternários
country is string = (Left(phone_number, 3) = "+55" ? "BRASIL" :
(Left(phone_number, 2) = "+1" ? "EUA" :
(Left(phone_number, 3) = "+44" ? "REINO_UNIDO" : "OUTRO")))

// Seleção de provedor usando EvaluateExpression
provider_scores is associative array of real

// Simular scores dos provedores
{provider_scores, "TWILIO"} = CalculateProviderScore("TWILIO", country, priority, message_text)
{provider_scores, "ZENVIA"} = CalculateProviderScore("ZENVIA", country, priority, message_text)
{provider_scores, "NEXMO"} = CalculateProviderScore("NEXMO", country, priority, message_text)

// Encontrar melhor provedor usando Indirection
best_provider is string = ""
best_score is real = -1

FOR EACH provider_id, score OF provider_scores
IF score > best_score
best_provider = provider_id
best_score = score
END//If
END//For

// Decisão de roteamento
routing_reason is string = (country = "BRASIL" AND best_provider = "ZENVIA" ? "Otimizado para Brasil" :
(priority = 0 AND best_provider = "TWILIO" ? "Máxima confiabilidade" :
(best_provider = "NEXMO" ? "Melhor custo-benefício" : "Padrão")))

Info(StringBuild(" 📱 %1 (%2) | Prioridade %3", phone_number, country, priority))
Info(StringBuild(" → Provedor: %1 (score: %2) | %3",
best_provider, NumToString(best_score, "0.000"), routing_reason))

// Simular envio
estimated_cost is real = CalculateEstimatedCostForProvider(best_provider, message_text, priority)
estimated_time is int = (priority = 0 ? 500 : (priority = 1 ? 1000 : 2000))

Info(StringBuild(" 💰 Custo estimado: R$ %1 | ⏱️ Tempo: %2ms",
NumToString(estimated_cost, "0.0000"), estimated_time))
END//For
END

// Procedure auxiliar para calcular score do provedor
Procedure CalculateProviderScore(provider_id is string, country is string, priority is int, message_text is string) : real
// Score base por provedor
base_score is real = (provider_id = "TWILIO" ? 0.9 :
(provider_id = "ZENVIA" ? 0.8 :
(provider_id = "NEXMO" ? 0.7 : 0.5)))

// Bonus por país usando EvaluateExpression
country_bonus is real = EvaluateExpression([
(country = "BRASIL" AND provider_id = "ZENVIA") ? 0.2 :
((country = "EUA" OR country = "REINO_UNIDO") AND provider_id = "TWILIO") ? 0.15 :
(provider_id = "NEXMO") ? 0.1 : 0.0
])

// Bonus por prioridade
priority_bonus is real = (priority = 0 AND provider_id = "TWILIO" ? 0.1 :
(priority = 1 ? 0.05 : 0.0))

// Score final
final_score is real = base_score + country_bonus + priority_bonus

Result final_score
END

// Exemplo 5: Cache dinâmico com técnicas avançadas
Procedure ExemploCacheDinamico(sms_system is ClasseWxSendSMS_v5)
Info("💾 Demonstrando Cache Dinâmico...")

// Exemplo 5.1: Cache de validação usando Indirection
validation_cache is associative array of boolean
test_numbers is array of string = ["+5511999999999", "invalid", "+1234567890", "+5511888888888"]

Info("🔍 Cache de validação:")
FOR i = 1 TO ArrayCount(test_numbers)
phone is string = test_numbers[i]
cache_key is string = "validation_" + MD5(phone)

// Verificar cache usando Indirection
cached_result is boolean = {validation_cache, cache_key}

IF cached_result <> Null
Info(StringBuild(" 📋 %1: %2 (CACHE HIT)", phone, (cached_result ? "✅ VÁLIDO" : "❌ INVÁLIDO")))
ELSE
// Validar e armazenar no cache
is_valid is boolean = sms_system.ValidateMessageAdvanced(phone, "Teste", "")
{validation_cache, cache_key} = is_valid

Info(StringBuild(" 🔄 %1: %2 (CACHE MISS)", phone, (is_valid ? "✅ VÁLIDO" : "❌ INVÁLIDO")))
END//If
END//For

// Exemplo 5.2: Cache inteligente com expiração
smart_cache is associative array of string
cache_expiry is associative array of DateTime

Info("⏰ Cache com expiração:")
cache_items is array of string = ["provider_stats", "routing_table", "cost_matrix", "performance_data"]

FOR i = 1 TO ArrayCount(cache_items)
cache_key is string = cache_items[i]
cache_value is string = StringBuild("Dados para %1 - %2", cache_key, DateTimeToString(DateTimeSys()))

// Definir expiração usando operador ternário
expiry_minutes is int = (cache_key = "provider_stats" ? 5 :
(cache_key = "routing_table" ? 15 :
(cache_key = "cost_matrix" ? 60 : 30)))

expiry_time is DateTime = DateTimeAdd(DateTimeSys(), expiry_minutes, duMinute)

// Armazenar usando Indirection
{smart_cache, cache_key} = cache_value
{cache_expiry, cache_key} = expiry_time

Info(StringBuild(" 💾 %1: expira em %2 min", cache_key, expiry_minutes))
END//For

// Simular acesso ao cache após algum tempo
Info("🕐 Simulando acesso ao cache:")
FOR i = 1 TO ArrayCount(cache_items)
cache_key is string = cache_items[i]

// Verificar expiração usando operador ternário
expiry_time is DateTime = {cache_expiry, cache_key}
is_expired is boolean = (DateTimeCompare(DateTimeSys(), expiry_time) > 0)

cache_status is string = (is_expired ? "🔴 EXPIRADO" : "🟢 VÁLIDO")
cached_value is string = (is_expired ? "" : {smart_cache, cache_key})

Info(StringBuild(" %1 %2: %3", cache_status, cache_key,
(Length(cached_value) > 0 ? "Dados disponíveis" : "Cache vazio")))
END//For
END

// Exemplo 6: Analytics em tempo real
Procedure ExemploAnalyticsTempoReal(sms_system is ClasseWxSendSMS_v5)
Info("📊 Demonstrando Analytics em Tempo Real...")

// Simular dados de analytics
analytics_data is associative array of string
providers is array of string = ["TWILIO", "ZENVIA", "NEXMO"]

Info("📈 Gerando métricas em tempo real:")
FOR i = 1 TO ArrayCount(providers)
provider_id is string = providers[i]

// Gerar métricas simuladas usando operadores ternários
total_sent is int = Random(500, 2000)
success_count is int = total_sent * (provider_id = "TWILIO" ? 0.95 :
(provider_id = "ZENVIA" ? 0.88 : 0.92))

avg_response_time is real = (provider_id = "TWILIO" ? Random(200, 300) :
(provider_id = "ZENVIA" ? Random(300, 450) : Random(250, 350)))

total_cost is real = total_sent * (provider_id = "TWILIO" ? 0.0075 :
(provider_id = "ZENVIA" ? 0.05 : 0.008))

// Calcular métricas derivadas usando EvaluateExpression
success_rate is real = EvaluateExpression([success_count / total_sent * 100])
cost_per_message is real = EvaluateExpression([total_cost / total_sent])
efficiency_score is real = EvaluateExpression([success_rate / 100 * (1000 / avg_response_time)])

// Armazenar métricas usando Indirection
metrics_json is string = StringBuild([
{
"total_sent": %1,
"success_count": %2,
"success_rate": %3,
"avg_response_time": %4,
"total_cost": %5,
"cost_per_message": %6,
"efficiency_score": %7,
"timestamp": "%8"
}], total_sent, success_count, success_rate, avg_response_time,
total_cost, cost_per_message, efficiency_score, DateTimeToString(DateTimeSys()))

{analytics_data, provider_id} = metrics_json

// Classificação de performance usando operadores ternários
performance_level is string = (efficiency_score >= 0.8 ? "🏆 EXCELENTE" :
(efficiency_score >= 0.6 ? "🥈 BOM" :
(efficiency_score >= 0.4 ? "🥉 REGULAR" : "⚠️ RUIM")))

Info(StringBuild(" %1 %2:", performance_level, provider_id))
Info(StringBuild(" 📤 %1 enviados | ✅ %2%% sucesso | ⏱️ %3ms | 💰 R$ %4",
total_sent, NumToString(success_rate, "0.0"), NumToString(avg_response_time, "0"),
NumToString(total_cost, "0.00")))
END//For

// Dashboard em tempo real
Info("📊 Dashboard consolidado:")
total_messages is int = 0
total_cost_all is real = 0
weighted_success_rate is real = 0

FOR EACH provider_id, metrics_json OF analytics_data
// Extrair dados do JSON (simulado)
sent is int = Random(500, 2000) // Simulação
cost is real = Random(10, 100) // Simulação
success is real = Random(85, 95) // Simulação

total_messages += sent
total_cost_all += cost
weighted_success_rate += (success * sent)
END//For

// Métricas consolidadas usando operadores ternários
avg_success_rate is real = (total_messages > 0 ? weighted_success_rate / total_messages : 0)
avg_cost_per_message is real = (total_messages > 0 ? total_cost_all / total_messages : 0)

system_health is string = (avg_success_rate >= 90 ? "🟢 SAUDÁVEL" :
(avg_success_rate >= 85 ? "🟡 ATENÇÃO" : "🔴 CRÍTICO"))

Info(StringBuild(" %1 Sistema: %2 mensagens | %3%% sucesso médio | R$ %4 custo médio",
system_health, total_messages, NumToString(avg_success_rate, "0.0"),
NumToString(avg_cost_per_message, "0.0000")))
END

// Exemplo 7: Threads inteligentes
Procedure ExemploThreadsInteligentes(sms_system is ClasseWxSendSMS_v5)
Info("🧵 Demonstrando Threads Inteligentes...")

// Simular cenários de carga
load_scenarios is array of string = [
"100:1:LIGHT", // 100 mensagens, prioridade alta, carga leve
"1000:2:MEDIUM", // 1000 mensagens, prioridade normal, carga média
"5000:0:HEAVY" // 5000 mensagens, prioridade crítica, carga pesada
]

Info("⚖️ Calculando configuração ótima de threads:")
FOR i = 1 TO ArrayCount(load_scenarios)
scenario_parts is array of string
StringToArray(load_scenarios[i], scenario_parts, ":")

message_count is int = Val(scenario_parts[1])
priority is int = Val(scenario_parts[2])
load_type is string = scenario_parts[3]

// Cálculo inteligente de threads usando EvaluateExpression
base_threads is int = EvaluateExpression([
Min(15, Max(2, Ceiling(message_count / 100)))
])

// Ajuste por prioridade usando operador ternário
priority_multiplier is real = (priority = 0 ? 1.5 :
(priority = 1 ? 1.2 : 1.0))

// Ajuste por carga do sistema
load_factor is real = (load_type = "LIGHT" ? 1.0 :
(load_type = "MEDIUM" ? 0.8 : 0.6))

optimal_threads is int = EvaluateExpression([
Max(2, Min(15, base_threads * priority_multiplier * load_factor))
])

// Configuração de delay usando operadores ternários
base_delay is int = (priority = 0 ? 100 :
(priority = 1 ? 300 : 500))

adaptive_delay is int = (load_type = "HEAVY" ? base_delay * 2 :
(load_type = "MEDIUM" ? base_delay * 1.5 : base_delay))

// Estimativa de tempo
estimated_duration is int = (message_count * adaptive_delay) / optimal_threads / 1000

// Classificação de eficiência
efficiency_rating is string = (estimated_duration <= 60 ? "⚡ MUITO RÁPIDO" :
(estimated_duration <= 300 ? "🚀 RÁPIDO" :
(estimated_duration <= 600 ? "⏰ MODERADO" : "🐌 LENTO")))

Info(StringBuild(" 📊 %1 mensagens | Prioridade %2 | Carga %3", message_count, priority, load_type))
Info(StringBuild(" → %1 threads | %2ms delay | %3 | ~%4s %5",
optimal_threads, adaptive_delay, efficiency_rating, estimated_duration,
(estimated_duration > 600 ? "⚠️" : "✅")))
END//For

// Simulação de balanceamento dinâmico
Info("⚖️ Simulando balanceamento dinâmico:")
thread_performance is associative array of real

// Simular performance de threads
FOR i = 1 TO 5
thread_id is string = "THREAD_" + i

// Performance simulada usando operadores ternários
base_performance is real = Random(70, 95) / 100.0
load_penalty is real = (i > 3 ? 0.1 : 0.0) // Threads extras têm penalty
performance_score is real = base_performance - load_penalty

{thread_performance, thread_id} = performance_score

// Status da thread usando operadores ternários
thread_status is string = (performance_score >= 0.9 ? "🟢 ÓTIMA" :
(performance_score >= 0.8 ? "🟡 BOA" :
(performance_score >= 0.7 ? "🟠 REGULAR" : "🔴 RUIM")))

// Ação recomendada
action is string = (performance_score >= 0.9 ? "Manter configuração" :
(performance_score >= 0.8 ? "Monitorar de perto" :
(performance_score >= 0.7 ? "Reduzir carga" : "Reiniciar thread")))

Info(StringBuild(" %1 %2: %3%% performance | %4",
thread_status, thread_id, NumToString(performance_score * 100, "0.0"), action))
END//For
END

// Procedure auxiliar para configurar provedores simulados
Procedure ConfigurarProvedoresSimulados(sms_system is ClasseWxSendSMS_v5)
// Configuração simulada dos provedores
sms_system.SetDynamicProperty("provider_twilio_active", True)
sms_system.SetDynamicProperty("provider_zenvia_active", True)
sms_system.SetDynamicProperty("provider_nexmo_active", True)

LogAdvanced("Provedores simulados configurados", "CONFIG")
END

// Procedure auxiliar para calcular custo estimado
Procedure CalculateEstimatedCostForProvider(provider_id is string, message_text is string, priority is int) : real
segments is int = Ceiling(Length(message_text) / 160.0)

// Custo base por provedor usando operador ternário
base_cost is real = (provider_id = "TWILIO" ? 0.0075 :
(provider_id = "ZENVIA" ? 0.05 :
(provider_id = "NEXMO" ? 0.008 : 0.01)))

// Multiplicador por prioridade
priority_multiplier is real = (priority = 0 ? 1.5 : 1.0)

Result segments * base_cost * priority_multiplier
END

// Procedure principal para executar todos os exemplos
Procedure ExecutarTodosExemplosAvancados()
Info("🚀 === INICIANDO DEMONSTRAÇÃO COMPLETA v5.0 ===")

// Executar demonstração completa
ExemploCompletoTecnicasAvancadas()

Info("✅ === DEMONSTRAÇÃO CONCLUÍDA COM SUCESSO ===")
Info("")
Info("📋 RESUMO DAS TÉCNICAS DEMONSTRADAS:")
Info(" ✅ EvaluateExpression - Validações e cálculos dinâmicos")
Info(" ✅ Indirection - Acesso dinâmico a propriedades e cache")
Info(" ✅ Operadores Ternários - Lógica condicional elegante")
Info(" ✅ Roteamento Inteligente - Seleção automática de provedores")
Info(" ✅ Cache Dinâmico - Otimização de performance")
Info(" ✅ Analytics Tempo Real - Monitoramento avançado")
Info(" ✅ Threads Inteligentes - Processamento otimizado")
Info("")
Info("🎉 ClasseWxSendSMS_v5 - O futuro do SMS em WLanguage!")
END

//Final do Arquivo