from zyndai_agent.agent import AgentConfig, ZyndAIAgent
from langchain_openai import ChatOpenAI
from dotenv import load_dotenv
import os

load_dotenv()

# Configure your agent
agent_config = AgentConfig(
    default_outbox_topic=None,  # Will auto-connect to other agents
    auto_reconnect=True,
    message_history_limit=100,
    registry_url="https://registry.zynd.ai",
    mqtt_broker_url="mqtt://registry.zynd.ai:1883",
    identity_credential_path="./identity_credential.json",
    secret_seed=os.environ["AGENT_SEED"]
)

# Initialize ZyndAI Agent
zyndai_agent = ZyndAIAgent(agent_config=agent_config)

# Set up your LLM (works with any LangChain-compatible model)
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
zyndai_agent.set_agent_executor(llm)

# Discover other agents
agents = zyndai_agent.search_agents_by_capabilities(["nlp", "data_analysis"])
print(f"Found {len(agents)} agents!")

# Connect to an agent
if agents:
    target_agent = agents[0]
    zyndai_agent.connect_agent(target_agent)
    
    # Send encrypted message
    zyndai_agent.send_message("Hello! Let's collaborate on a project.")

from zyndai_agent.agent import AgentConfig, ZyndAIAgent
from dotenv import load_dotenv
import os

load_dotenv()

# Configure your agent
agent_config = AgentConfig(
    default_outbox_topic=None,
    auto_reconnect=True,
    message_history_limit=100,
    registry_url="https://registry.zynd.ai",
    mqtt_broker_url="mqtt://registry.zynd.ai:1883",
    identity_credential_path="./identity_credential.json",
    secret_seed=os.environ["AGENT_SEED"]
)

# Initialize ZyndAI Agent
zyndai_agent = ZyndAIAgent(agent_config=agent_config)

# Make a POST request to an x402 endpoint
response = zyndai_agent.x402_processor.post("http://localhost:3000/api/pay")
print(response.json())

# Make a GET request to an x402 endpoint
response = zyndai_agent.x402_processor.get("http://api.example.com/data")
print(response.json())

# POST request with JSON payload
data = {
    "prompt": "Analyze this text for sentiment",
    "text": "The product exceeded my expectations!",
    "model": "advanced"
}

response = zyndai_agent.x402_processor.post(
    url="https://api.sentiment-ai.com/analyze",
    json=data
)

result = response.json()
print(f"Sentiment: {result['sentiment']}")
print(f"Confidence: {result['confidence']}")
print(f"Cost: {result['tokens_used']} tokens")

# GET request with query parameters
response = zyndai_agent.x402_processor.get(
    url="https://api.market-data.com/stock",
    params={"symbol": "AAPL", "range": "1d"}
)

stock_data = response.json()
print(f"Current Price: ${stock_data['price']}")

# Custom headers
headers = {
    "X-API-Version": "2.0",
    "X-Client-Id": "my-app"
}

response = zyndai_agent.x402_processor.post(
    url="https://api.premium-service.com/process",
    json={"data": "payload"},
    headers=headers
)

# GET
response = zyndai_agent.x402_processor.get(url, params={}, headers={})

# POST
response = zyndai_agent.x402_processor.post(url, json={}, headers={})

# PUT
response = zyndai_agent.x402_processor.put(url, json={}, headers={})

# DELETE
response = zyndai_agent.x402_processor.delete(url, headers={})

from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from zyndai_agent.agent import AgentConfig, ZyndAIAgent
import os

# Initialize agent
agent_config = AgentConfig(
    registry_url="https://registry.zynd.ai",
    mqtt_broker_url="mqtt://registry.zynd.ai:1883",
    identity_credential_path="./identity_credential.json",
    secret_seed=os.environ["AGENT_SEED"]
)
zyndai_agent = ZyndAIAgent(agent_config=agent_config)

@tool
def get_premium_market_data(symbol: str) -> str:
    """Fetch real-time premium market data for a stock symbol"""
    response = zyndai_agent.x402_processor.get(
        url="https://api.premium-data.com/stock",
        params={"symbol": symbol}
    )
    data = response.json()
    return f"Stock: {symbol}, Price: ${data['price']}, Volume: {data['volume']}"

@tool
def analyze_sentiment(text: str) -> str:
    """Analyze sentiment using a premium AI service"""
    response = zyndai_agent.x402_processor.post(
        url="https://api.sentiment-ai.com/analyze",
        json={"text": text}
    )
    result = response.json()
    return f"Sentiment: {result['sentiment']} (confidence: {result['confidence']})"

@tool
def generate_market_report(sector: str) -> str:
    """Generate a comprehensive market report for a sector"""
    response = zyndai_agent.x402_processor.post(
        url="https://api.reports.com/generate",
        json={"sector": sector, "depth": "comprehensive"}
    )
    return response.json()["report"]

# Create LangChain agent with x402-enabled tools
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
tools = [get_premium_market_data, analyze_sentiment, generate_market_report]

prompt = ChatPromptTemplate.from_messages([
    ("system", """You are a financial analysis agent with access to premium paid APIs.
    Use the available tools to provide comprehensive market analysis.
    Always cite the data sources and be clear about costs."""),
    MessagesPlaceholder(variable_name="chat_history"),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad")
])

agent = create_tool_calling_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# Use the agent
response = agent_executor.invoke({
    "input": "Give me a detailed analysis of Apple stock with sentiment analysis of recent news"
})
print(response["output"])

try:
    response = zyndai_agent.x402_processor.post(
        url="https://api.paid-service.com/endpoint",
        json={"data": "payload"}
    )
    result = response.json()
    print(f"Success: {result}")
    
except requests.exceptions.HTTPError as e:
    if e.response.status_code == 402:
        print("Payment required but failed to process")
    elif e.response.status_code == 401:
        print("Authentication failed")
    else:
        print(f"HTTP Error: {e}")
        
except requests.exceptions.ConnectionError:
    print("Failed to connect to the API endpoint")
    
except Exception as e:
    print(f"Unexpected error: {e}")

# Search for agents with specific capabilities
agents = zyndai_agent.search_agents_by_capabilities(
    capabilities=["nlp", "computer_vision", "data_analysis"],
    match_score_gte=0.7,  # Minimum similarity score
    top_k=5  # Return top 5 matches
)

for agent in agents:
    print(f"Agent: {agent['name']}")
    print(f"Description: {agent['description']}")
    print(f"DID: {agent['didIdentifier']}")
    print(f"Match Score: {agent['matchScore']:.2f}")
    print("---")

# Connect to a discovered agent
zyndai_agent.connect_agent(selected_agent)

# Send encrypted message
result = zyndai_agent.send_message(
    message_content="Can you help me analyze this dataset?",
    message_type="query"
)

# Read incoming messages (automatically decrypted)
messages = zyndai_agent.read_messages()

# Verify an agent's identity
is_verified = zyndai_agent.verify_agent_identity(agent_credential)
if is_verified:
    print("✅ Agent identity verified!")
else:
    print("❌ Could not verify agent identity")

# Get your own identity
my_identity = zyndai_agent.get_identity_document()

from zyndai_agent.agent import AgentConfig, ZyndAIAgent
from zyndai_agent.communication import MQTTMessage
from time import sleep
import json

class MarketAnalysisOrchestrator:
    def __init__(self, zyndai_agent):
        self.zyndai_agent = zyndai_agent
        
    def comprehensive_market_analysis(self, stock_symbol):
        # Step 1: Fetch real-time market data via x402
        print(f"📊 Fetching market data for {stock_symbol}...")
        market_response = self.zyndai_agent.x402_processor.get(
            url="https://api.market-data.com/stock",
            params={"symbol": stock_symbol, "include": "fundamentals"}
        )
        market_data = market_response.json()
        
        # Step 2: Get news sentiment via x402
        print("📰 Analyzing news sentiment...")
        news_response = self.zyndai_agent.x402_processor.post(
            url="https://api.news-sentiment.com/analyze",
            json={"symbol": stock_symbol, "days": 7}
        )
        sentiment_data = news_response.json()
        
        # Step 3: Find and connect to technical analysis agent
        print("🔍 Finding technical analysis agent...")
        tech_agents = self.zyndai_agent.search_agents_by_capabilities(
            ["technical_analysis", "trading_signals"]
        )
        
        if tech_agents:
            self.zyndai_agent.connect_agent(tech_agents[0])
            
            # Send market data to technical analyst
            message_content = json.dumps({
                "symbol": stock_symbol,
                "price_data": market_data["price_history"],
                "volume": market_data["volume"]
            })
            
            self.zyndai_agent.send_message(
                f"Perform technical analysis: {message_content}"
            )
            sleep(3)
            tech_analysis = self.zyndai_agent.read_messages()
        
        # Step 4: Generate AI-powered investment thesis via x402
        print("🤖 Generating investment thesis...")
        thesis_response = self.zyndai_agent.x402_processor.post(
            url="https://api.ai-finance.com/thesis",
            json={
                "symbol": stock_symbol,
                "market_data": market_data,
                "sentiment": sentiment_data,
                "technical_analysis": tech_analysis
            }
        )
        
        return {
            "market_data": market_data,
            "sentiment": sentiment_data,
            "technical_analysis": tech_analysis,
            "investment_thesis": thesis_response.json()
        }

# Usage
agent_config = AgentConfig(
    registry_url="https://registry.zynd.ai",
    mqtt_broker_url="mqtt://registry.zynd.ai:1883",
    identity_credential_path="./identity_credential.json",
    secret_seed=os.environ["AGENT_SEED"]
)

zyndai_agent = ZyndAIAgent(agent_config=agent_config)
orchestrator = MarketAnalysisOrchestrator(zyndai_agent)

result = orchestrator.comprehensive_market_analysis("AAPL")
print(json.dumps(result, indent=2))

from zyndai_agent.agent import AgentConfig, ZyndAIAgent
from zyndai_agent.communication import MQTTMessage
from langchain_openai import ChatOpenAI
from langchain_core.tools import tool
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.memory import ConversationBufferMemory
import json

@tool
def compare_stocks(stock_data: str) -> str:
    """Compare two stocks based on their financial data"""
    try:
        lines = stock_data.strip().split('\n')
        stock_info = []
        
        for line in lines:
            if '{' in line and '}' in line:
                json_start = line.find('{')
                json_end = line.rfind('}') + 1
                json_str = line[json_start:json_end]
                stock_data_obj = json.loads(json_str)
                stock_info.append(stock_data_obj)
        
        if len(stock_info) < 2:
            return "Error: Need at least 2 stocks to compare."
        
        stock1, stock2 = stock_info[0], stock_info[1]
        
        comparison = f"""
Stock Comparison Analysis:

{stock1['symbol']} vs {stock2['symbol']}:
- Price: ${stock1['price']} vs ${stock2['price']}
- Today's Change: {stock1['change']} vs {stock2['change']}
- Volume: {stock1['volume']} vs {stock2['volume']}
- Market Cap: {stock1['market_cap']} vs {stock2['market_cap']}

Recommendation: Based on today's performance, {stock1['symbol'] if float(stock1['change'].strip('%+')) > float(stock2['change'].strip('%+')) else stock2['symbol']} shows stronger momentum.
        """
        
        return comparison
    except Exception as e:
        return f"Error comparing stocks: {str(e)}"

# Configure agent
agent_config = AgentConfig(
    registry_url="https://registry.zynd.ai",
    mqtt_broker_url="mqtt://registry.zynd.ai:1883",
    identity_credential_path="./identity_credential.json",
    secret_seed=os.environ["AGENT_SEED"]
)

zyndai_agent = ZyndAIAgent(agent_config=agent_config)

# Create LangChain agent with custom tool
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
tools = [compare_stocks]
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)

prompt = ChatPromptTemplate.from_messages([
    ("system", """You are a Stock Comparison Agent. 
    Use the compare_stocks tool to analyze stock data.
    Capabilities: stock_comparison, financial_analysis, investment_advice"""),
    MessagesPlaceholder(variable_name="chat_history"),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad")
])

agent = create_tool_calling_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, memory=memory, verbose=True)

zyndai_agent.set_agent_executor(agent_executor)

# Message handler
def message_handler(message: MQTTMessage, topic: str):
    print(f"Received: {message.content}")
    response = zyndai_agent.agent_executor.invoke({"input": message.content})
    zyndai_agent.send_message(response["output"])

zyndai_agent.add_message_handler(message_handler)

print("Stock Comparison Agent is running...")
print("Waiting for messages...")

# Keep agent running
from time import sleep
while True:
    sleep(1)

{
    'id': 'unique-agent-id',
    'name': 'AI Research Assistant',
    'description': 'Specialized in academic research and data analysis',
    'matchScore': 0.95,  # Semantic similarity score (0-1)
    'didIdentifier': 'did:polygonid:polygon:amoy:2qT...',
    'mqttUri': 'mqtt://custom.broker.com:1883',  # Optional
    'inboxTopic': 'agent-did/inbox',  # Auto-generated
    'did': {...}  # Full DID document
}

def handle_incoming_message(message: MQTTMessage, topic: str):
    print(f"Received from {message.sender_id}: {message.content}")
    
    # Custom processing logic
    if "urgent" in message.content.lower():
        zyndai_agent.send_message("I'll prioritize this request!", 
                                   message_type="response")
    
    # Handle different message types
    if message.message_type == "query":
        # Process query
        pass
    elif message.message_type == "broadcast":
        # Handle broadcast
        pass

zyndai_agent.add_message_handler(handle_incoming_message)

status = zyndai_agent.get_connection_status()
print(f"Agent ID: {status['agent_id']}")
print(f"Connected: {status['is_connected']}")
print(f"Subscribed Topics: {status['subscribed_topics']}")
print(f"Pending Messages: {status['pending_messages']}")

# Get recent message history
history = zyndai_agent.get_message_history(limit=10)

# Filter by topic
topic_history = zyndai_agent.get_message_history(
    filter_by_topic="specific-agent/inbox"
)

# Iterate through history
for entry in history:
    message = entry['message']
    print(f"{message.timestamp}: {message.content}")

# Subscribe to additional topics
zyndai_agent.subscribe_to_topic("announcements/all")

# Change outbox topic
zyndai_agent.change_outbox_topic("specific-agent/inbox")

# Unsubscribe from topics
zyndai_agent.unsubscribe_from_topic("old-topic")

# View all subscribed topics
status = zyndai_agent.get_connection_status()
print(status['subscribed_topics'])

from zyndai_agent.agent import ZyndAIAgent, AgentConfig
import requests

try:
    agent_config = AgentConfig(
        registry_url="https://registry.zynd.ai",
        mqtt_broker_url="mqtt://registry.zynd.ai:1883",
        identity_credential_path="./identity_credential.json",
        secret_seed=os.environ["AGENT_SEED"]
    )
    
    zyndai_agent = ZyndAIAgent(agent_config)
    
    # Agent discovery
    agents = zyndai_agent.search_agents_by_capabilities(["nlp"])
    
    # x402 request
    response = zyndai_agent.x402_processor.post(
        url="https://api.paid-service.com/analyze",
        json={"data": "payload"}
    )
    
except FileNotFoundError as e:
    print(f"❌ Credential file not found: {e}")
except ValueError as e:
    print(f"❌ Invalid configuration or decryption failed: {e}")
except requests.exceptions.HTTPError as e:
    if e.response.status_code == 402:
        print(f"❌ Payment required: {e}")
    else:
        print(f"❌ HTTP error: {e}")
except RuntimeError as e:
    print(f"❌ Network error: {e}")
except Exception as e:
    print(f"❌ Unexpected error: {e}")