from neogenesis_system.langchain_integration.distributed_state import DistributedStateManager

# Configure distributed coordination
distributed_state = DistributedStateManager(
    node_id="neogenesis_node_1",
    cluster_nodes=["node_1:8001", "node_2:8002", "node_3:8003"],
    consensus_protocol="raft"
)

# Distribute decision state across cluster
await distributed_state.broadcast_decision_update({
    "session_id": "global_decision_001",
    "chosen_path": {"id": 5, "confidence": 0.93},
    "timestamp": time.time()
})

from neogenesis_system.langchain_integration.advanced_chains import AdvancedChainComposer

# Create sophisticated decision workflow
composer = AdvancedChainComposer()

# Define parallel analysis chains
technical_analysis = composer.create_parallel_chain([
    "architecture_evaluation",
    "performance_analysis", 
    "security_assessment"
])

# Define sequential decision chain
decision_workflow = composer.create_sequential_chain([
    "problem_analysis",
    technical_analysis,  # Parallel sub-chain
    "cost_benefit_analysis",
    "risk_assessment",
    "final_recommendation"
])

# Execute with state persistence
result = await composer.execute_chain(
    chain=decision_workflow,
    input_data={"project": "cloud_migration", "scale": "enterprise"},
    persist_state=True,
    session_id="migration_decision_001"
)

from neogenesis_system.langchain_integration.execution_engines import ParallelExecutionEngine

# Configure high-performance execution
engine = ParallelExecutionEngine(
    max_workers=8,
    execution_timeout=300,
    retry_strategy="exponential_backoff"
)

# Execute multiple decision paths in parallel
paths_to_evaluate = [
    {"path_id": 1, "strategy": "microservices_approach"},
    {"path_id": 2, "strategy": "monolithic_approach"},
    {"path_id": 3, "strategy": "hybrid_approach"}
]

results = await engine.execute_parallel(
    tasks=paths_to_evaluate,
    evaluation_function="evaluate_architecture_path"
)

from neogenesis_system.langchain_integration import (
    create_neogenesis_chain, 
    PersistentStateManager,
    AdvancedChainComposer
)

# Create LangChain-compatible Neogenesis chain
neogenesis_chain = create_neogenesis_chain(
    storage_backend="lmdb",
    enable_distributed_state=True,
    session_persistence=True
)

# Use as standard LangChain component
from langchain.chains import SequentialChain

# Integrate with existing LangChain workflows
full_workflow = SequentialChain(chains=[
    preprocessing_chain,       # Standard LangChain chain
    neogenesis_chain,         # Our intelligent decision engine
    postprocessing_chain      # Standard LangChain chain
])

# Execute with persistent state
result = full_workflow.run({
    "input": "Design scalable microservices architecture",
    "context": {"team_size": 15, "timeline": "6_months"}
})

from neogenesis_system.langchain_integration.coordinators import EnterpriseCoordinator

# Configure enterprise-grade decision workflow
coordinator = EnterpriseCoordinator(
    storage_config={
        "backend": "lmdb",
        "encryption": True,
        "backup_enabled": True
    },
    distributed_config={
        "cluster_size": 3,
        "consensus_protocol": "raft"
    }
)

# Execute complex business decision
decision_result = await coordinator.execute_enterprise_decision(
    query="Should we acquire startup company TechCorp for $50M?",
    context={
        "industry": "fintech",
        "company_stage": "series_b",
        "financial_position": "strong",
        "strategic_goals": ["market_expansion", "talent_acquisition"]
    },
    analysis_depth="comprehensive",
    stakeholder_perspectives=["ceo", "cto", "cfo", "head_of_strategy"]
)

# Access persistent decision history
decision_history = coordinator.get_decision_history(
    filters={"domain": "mergers_acquisitions", "timeframe": "last_year"}
)

import os
from dotenv import load_dotenv
from meta_mab.controller import MainController

# Load environment variables
load_dotenv()

# Initialize controller (auto-detects available LLM providers)
controller = MainController()

# The system automatically selects the best available LLM provider
# You can check which providers are available
status = controller.get_llm_provider_status()
print(f"Available providers: {status['healthy_providers']}/{status['total_providers']}")

# Pose a complex question
query = "Design a scalable, low-cost cloud-native tech stack for a startup tech company"
context = {"domain": "cloud_native_architecture", "company_stage": "seed"}

# Get AI's decision (automatically uses the best available provider)
decision_result = controller.make_decision(user_query=query, execution_context=context)

# View the final chosen thinking path
chosen_path = decision_result.get('chosen_path')
if chosen_path:
    print(f"🚀 AI's chosen thinking path: {chosen_path.path_type}")
    print(f"📝 Core approach: {chosen_path.description}")

# (Optional) Switch to a specific provider
controller.switch_llm_provider("openai")  # or "anthropic", "deepseek", etc.

# (Optional) Provide execution result feedback to help AI learn
controller.update_performance_feedback(
    decision_result=decision_result,
    execution_success=True,
    execution_time=12.5,
    user_satisfaction=0.9,
    rl_reward=0.85
)
print("\n✅ AI has received feedback and completed learning!")

# Tool Integration Examples
print("\n" + "="*50)
print("🔧 Tool-Enhanced Decision Making Examples")
print("="*50)

# Check available tools
from meta_mab.utils.tool_abstraction import list_available_tools, get_registry_stats
tools = list_available_tools()
stats = get_registry_stats()
print(f"📊 Available tools: {len(tools)} ({', '.join(tools)})")
print(f"📈 Tool registry stats: {stats['total_tools']} tools, {stats['success_rate']:.1%} success rate")

# Direct tool usage example
from meta_mab.utils.tool_abstraction import execute_tool
search_result = execute_tool("web_search", query="latest trends in cloud computing 2024", max_results=3)
if search_result and search_result.success:
    print(f"🔍 Web search successful: Found {len(search_result.data.get('results', []))} results")
else:
    print(f"❌ Web search failed: {search_result.error_message if search_result else 'No result'}")

# Tool-enhanced verification example
verification_result = execute_tool("idea_verification", 
                                 idea="Implement blockchain-based supply chain tracking for food safety",
                                 context={"industry": "food_tech", "scale": "enterprise"})
if verification_result and verification_result.success:
    analysis = verification_result.data.get('analysis', {})
    print(f"💡 Idea verification: Feasibility score {analysis.get('feasibility_score', 0):.2f}")
else:
    print(f"❌ Idea verification failed: {verification_result.error_message if verification_result else 'No result'}")

# Product strategy decisions
result = controller.make_decision(
    "How to prioritize features for our SaaS product for next quarter?",
    execution_context={
        "industry": "software",
        "stage": "growth",
        "constraints": ["budget_limited", "team_capacity"]
    }
)

# Architecture design decisions
result = controller.make_decision(
    "Design a real-time recommendation system supporting tens of millions of concurrent users",
    execution_context={
        "domain": "system_architecture", 
        "scale": "large",
        "requirements": ["real_time", "high_availability"]
    }
)

# Market analysis decisions
result = controller.make_decision(
    "Analyze competitive landscape and opportunities in the AI tools market",
    execution_context={
        "analysis_type": "market_research",
        "time_horizon": "6_months",
        "focus": ["opportunities", "threats"]
    }
)

# Tool-enhanced technical decisions with real-time information gathering
result = controller.make_decision(
    "Should we adopt Kubernetes for our microservices architecture?",
    execution_context={
        "domain": "system_architecture",
        "team_size": "10_engineers", 
        "current_stack": ["docker", "aws"],
        "constraints": ["learning_curve", "migration_complexity"]
    }
)

# The system automatically:
# 1. Uses WebSearchTool to gather latest Kubernetes trends and best practices
# 2. Applies IdeaVerificationTool to validate feasibility based on team constraints
# 3. Integrates real-time information into decision-making process
# 4. Provides evidence-based recommendations with source citations

print(f"Tool-enhanced decision: {result.get('chosen_path', {}).get('description', 'N/A')}")
print(f"Tools used: {result.get('tools_used', [])}")
print(f"Information sources: {result.get('verification_sources', [])}")

# Check available providers and their status
status = controller.get_llm_provider_status()
print(f"Healthy providers: {status['healthy_providers']}")

# Switch to a specific provider for particular tasks
controller.switch_llm_provider("anthropic")  # Use Claude for complex reasoning
result_reasoning = controller.make_decision("Complex philosophical analysis...")

controller.switch_llm_provider("deepseek")   # Use DeepSeek for coding tasks
result_coding = controller.make_decision("Optimize this Python algorithm...")

controller.switch_llm_provider("openai")     # Use GPT for general tasks
result_general = controller.make_decision("Business strategy planning...")

# Get cost and usage statistics
cost_summary = controller.get_llm_cost_summary()
print(f"Total cost: ${cost_summary['total_cost_usd']:.4f}")
print(f"Requests by provider: {cost_summary['cost_by_provider']}")

# Run health check on all providers
health_status = controller.run_llm_health_check()
print(f"Provider health: {health_status}")

from neogenesis_system.langchain_integration import (
    create_neogenesis_chain,
    StateManager,
    DistributedStateManager
)

# Create enterprise-grade persistent workflow
state_manager = StateManager(storage_backend="lmdb", enable_encryption=True)
neogenesis_chain = create_neogenesis_chain(
    state_manager=state_manager,
    enable_persistence=True,
    session_id="enterprise_decision_2024"
)

# Execute long-running decision process with state persistence
result = neogenesis_chain.execute({
    "query": "Develop comprehensive digital transformation strategy",
    "context": {
        "industry": "manufacturing",
        "company_size": "enterprise",
        "timeline": "3_years",
        "budget": "10M_USD",
        "current_state": "legacy_systems"
    }
})

# Access persistent decision history
decision_timeline = state_manager.get_decision_timeline("enterprise_decision_2024")
print(f"Decision milestones: {len(decision_timeline)} checkpoints")

from neogenesis_system.langchain_integration.advanced_chains import AdvancedChainComposer
from neogenesis_system.langchain_integration.execution_engines import ParallelExecutionEngine

# Configure parallel analysis workflow
composer = AdvancedChainComposer()
execution_engine = ParallelExecutionEngine(max_workers=6)

# Create specialized analysis chains
market_analysis_chain = composer.create_analysis_chain("market_research")
technical_analysis_chain = composer.create_analysis_chain("technical_feasibility")  
financial_analysis_chain = composer.create_analysis_chain("financial_modeling")
risk_analysis_chain = composer.create_analysis_chain("risk_assessment")

# Execute parallel comprehensive analysis
parallel_analysis = composer.create_parallel_chain([
    market_analysis_chain,
    technical_analysis_chain,
    financial_analysis_chain,
    risk_analysis_chain
])

# Run analysis with persistent state and error recovery
result = await execution_engine.execute_chain(
    chain=parallel_analysis,
    input_data={
        "project": "AI-powered customer service platform",
        "market": "enterprise_software",
        "timeline": "18_months"
    },
    persist_state=True,
    enable_recovery=True
)

print(f"Analysis completed: {result['analysis_summary']}")
print(f"Execution time: {result['execution_time']:.2f}s")

from neogenesis_system.langchain_integration.distributed_state import DistributedStateManager
from neogenesis_system.langchain_integration.coordinators import ClusterCoordinator

# Configure distributed decision cluster
distributed_state = DistributedStateManager(
    node_id="decision_node_1",
    cluster_nodes=["node_1:8001", "node_2:8002", "node_3:8003"],
    consensus_protocol="raft"
)

cluster_coordinator = ClusterCoordinator(
    distributed_state=distributed_state,
    load_balancing="intelligent"
)

# Execute distributed decision with consensus
decision_result = await cluster_coordinator.execute_distributed_decision(
    query="Should we enter the European market with our fintech product?",
    context={
        "industry": "fintech",
        "target_markets": ["germany", "france", "uk"],
        "regulatory_complexity": "high",
        "competition_level": "intense"
    },
    require_consensus=True,
    min_node_agreement=2
)

# Access cluster decision metrics
cluster_stats = cluster_coordinator.get_cluster_stats()
print(f"Nodes participated: {cluster_stats['active_nodes']}")
print(f"Consensus achieved: {cluster_stats['consensus_reached']}")
print(f"Decision confidence: {decision_result['confidence']:.2f}")

from langchain.chains import SequentialChain, LLMChain
from langchain.prompts import PromptTemplate
from neogenesis_system.langchain_integration.adapters import NeogenesisLangChainAdapter

# Create standard LangChain components
prompt = PromptTemplate(template="Analyze the market for {product}", input_variables=["product"])
market_chain = LLMChain(llm=llm, prompt=prompt)

# Create Neogenesis intelligent decision chain
neogenesis_adapter = NeogenesisLangChainAdapter(
    storage_backend="lmdb",
    enable_advanced_reasoning=True
)
neogenesis_chain = neogenesis_adapter.create_decision_chain()

# Combine in standard LangChain workflow
complete_workflow = SequentialChain(
    chains=[
        market_chain,           # Standard LangChain analysis
        neogenesis_chain,       # Intelligent Neogenesis decision-making
        market_chain            # Follow-up LangChain processing
    ],
    input_variables=["product"],
    output_variables=["final_recommendation"]
)

# Execute integrated workflow
result = complete_workflow.run({
    "product": "AI-powered legal document analyzer"
})

print(f"Integrated analysis result: {result}")