import { SDK } from 'agent0-sdk';

import { SDK } from 'agent0-sdk';

// Initialize SDK with IPFS and subgraph
const sdk = new SDK({
  chainId: 11155111, // Ethereum Sepolia testnet (use 1 for Ethereum Mainnet)
  rpcUrl: process.env.RPC_URL, // Optional for supported chains (built-in default RPC is used if omitted)
  privateKey: process.env.PRIVATE_KEY ?? process.env.AGENT_PRIVATE_KEY, // Optional: for write operations
  ipfs: 'pinata', // Options: 'pinata', 'filecoinPin', 'node' (Kubo daemon), 'helia' (embedded)
  pinataJwt: process.env.PINATA_JWT // For Pinata
  // Subgraph URL auto-defaults from DEFAULT_SUBGRAPH_URLS
});

import { SDK } from 'agent0-sdk';
import { discoverEip6963Providers, connectEip1193 } from 'agent0-sdk/eip6963';

const providers = await discoverEip6963Providers();
if (providers.length === 0) throw new Error('No injected wallets found');

// Pick a wallet (UI selection recommended)
const { provider } = providers[0];
await connectEip1193(provider); // prompts user

const sdk = new SDK({
  chainId: 11155111,
  rpcUrl: 'https://sepolia.infura.io/v3/YOUR_PROJECT_ID',
  walletProvider: provider,
});

// Create agent
const agent = sdk.createAgent(
  'My AI Agent',
  'An intelligent assistant for various tasks. Skills: data analysis, code generation.',
  'https://example.com/agent-image.png'
);

// Configure endpoints (automatically extracts capabilities)
await agent.setMCP('https://mcp.example.com/'); // Extracts tools, prompts, resources
await agent.setA2A('https://a2a.example.com/agent-card.json'); // Extracts skills
agent.setENS('myagent.eth');

// Add OASF skills and domains (standardized taxonomies)
agent.addSkill('data_engineering/data_transformation_pipeline', true);
agent.addSkill('natural_language_processing/natural_language_generation/summarization', true);
agent.addDomain('finance_and_business/investment_services', true);
agent.addDomain('technology/data_science/data_science', true);

// Optionally set a dedicated agent wallet on-chain (requires new wallet signature).
// If you want agentWallet = owner wallet, you can skip this (contract sets initial value to owner).
// await agent.setWallet('0x...', { newWalletPrivateKey: process.env.NEW_WALLET_PRIVATE_KEY });
agent.setTrust(true, true, false); // reputation, cryptoEconomic, teeAttestation

// Add metadata and set status
agent.setMetadata({ version: '1.0.0', category: 'ai-assistant' });
agent.setActive(true);

// Register on-chain with IPFS
const registrationFile = await agent.registerIPFS();
console.log(`Agent registered: ${registrationFile.agentId}`); // e.g., "11155111:123"
console.log(`Agent URI: ${registrationFile.agentURI}`); // e.g., "ipfs://Qm..."

// Register (or update) with a fully on-chain registration file (data URI)
const tx = await agent.registerOnChain();
const { result: registrationFile } = await tx.waitConfirmed({ timeoutMs: 180_000 });
console.log(`Agent URI (on-chain data): ${registrationFile.agentURI}`);

const sdk = new SDK({
  chainId: 11155111,
  rpcUrl: process.env.RPC_URL!,
  registrationDataUriMaxBytes: 512 * 1024,
});

// Load existing agent for editing
const agent = await sdk.loadAgent('11155111:123'); // Format: "chainId:agentId"

// Edit agent properties
agent.updateInfo(undefined, 'Updated description with new capabilities', undefined);
await agent.setMCP('https://new-mcp.example.com/');

// Re-register to update on-chain
await agent.registerIPFS();
console.log(`Updated: ${agent.agentURI}`);

// Unified search (single chain): agent filters + reputation filters in one call
const results = await sdk.searchAgents(
  {
    name: 'AI', // substring
    mcpTools: ['code_generation'],
    a2aSkills: ['python'],
    active: true,
    x402support: true,
    feedback: { minValue: 80, tag: 'enterprise', includeRevoked: false },
  },
  { sort: ['updatedAt:desc'] }
);

for (const agent of results) {
  console.log(`${agent.name}: ${agent.description}`);
  console.log(`  Tools: ${agent.mcpTools?.join(', ')}`);
  console.log(`  Skills: ${agent.a2aSkills?.join(', ')}`);
}

// Multi-chain search (SDK defaults include 1, 11155111, 137)
const multiChainResults = await sdk.searchAgents({ active: true, chains: [1, 11155111, 137] });

console.log(`Found ${multiChainResults.length} agents across chains`);

// Get single agent (read-only, faster)
// Supports chainId:agentId format
const agentSummary = await sdk.getAgent('11155111:123'); // explicit chainId:agentId

// Search across multiple chains
const results = await sdk.searchAgents({
  active: true,
  chains: [1, 11155111, 137] // Ethereum Mainnet, Ethereum Sepolia, Polygon Mainnet
});

// Search all configured chains
const allResults = await sdk.searchAgents({
  active: true,
  chains: 'all' // Searches all configured chains
});

// Search agents by feedback-derived reputation across chains (unified search)
const reputationResults = await sdk.searchAgents(
  { chains: [1, 11155111, 137], feedback: { minValue: 80, includeRevoked: false } }
);

// Get agent from specific chain
const agent = await sdk.getAgent('1:123'); // Ethereum Mainnet

// Search feedback for a specific agent (unchanged)
const feedbacks = await sdk.searchFeedback({ agentId: '1:123' }); // Ethereum Mainnet

// NEW: Search feedback given by a reviewer wallet (across all agents)
const givenFeedback = await sdk.searchFeedback({
  reviewers: ['0x742d35cc6634c0532925a3b844bc9e7595f0beb7'],
});

// NEW: Search feedback across multiple agents at once
const multiFeedback = await sdk.searchFeedback({
  agents: ['1:123', '1:456', '11155111:789'],
});

// Get reputation summary for agent on specific chain
const summary = await sdk.getReputationSummary('1:123'); // Ethereum Mainnet

// Optional: prepare an OFF-CHAIN feedback file (only needed for rich fields)
const feedbackFile = sdk.prepareFeedbackFile({
  text: 'Great agent!',
  mcpTool: 'code_generation',
  a2aSkills: ['python'],
  a2aContextId: 'session:abc',
});

// Give feedback (on-chain fields are passed directly)
const tx = await sdk.giveFeedback(
  '11155111:123',
  85, // value (number|string)
  'data_analyst', // tag1 (optional)
  'finance', // tag2 (optional)
  'https://api.example.com/feedback', // endpoint (optional on-chain)
  feedbackFile // optional off-chain file
);
// Submitted-by-default: wait explicitly for confirmation to get a receipt + the domain result
const { receipt, result: feedback } = await tx.waitConfirmed();

// Search feedback
const feedbackResults = await sdk.searchFeedback(
  { agentId: '11155111:123', capabilities: ['code_generation'] }, // capabilities filters by feedbackFile.mcpTool
  { minValue: 80, maxValue: 100 }
);

// Get reputation summary
const summary = await sdk.getReputationSummary('11155111:123');
console.log(`Average value: ${summary.averageValue}`);

// Option 1: Filecoin Pin (free for ERC-8004 agents)
const sdk = new SDK({
  chainId: 11155111,
  rpcUrl: '...',
  signer: privateKey,
  ipfs: 'filecoinPin',
  filecoinPrivateKey: 'your-filecoin-private-key'
});

// Option 2: Embedded Helia (no daemon required)
const sdk = new SDK({
  chainId: 11155111,
  rpcUrl: '...',
  signer: privateKey,
  ipfs: 'helia',
});

// Option 3: IPFS Node (Kubo daemon HTTP RPC API)
const sdk = new SDK({
  chainId: 11155111,
  rpcUrl: '...',
  signer: privateKey,
  ipfs: 'node',
  ipfsNodeUrl: 'http://localhost:5001'
});

// Option 4: Pinata (free for ERC-8004 agents)
const sdk = new SDK({
  chainId: 11155111,
  rpcUrl: '...',
  signer: privateKey,
  ipfs: 'pinata',
  pinataJwt: 'your-pinata-jwt-token'
});

// Option 5: HTTP registration (no IPFS)
const sdk = new SDK({ chainId: 11155111, rpcUrl: '...', signer: privateKey });
const regTx = await agent.registerHTTP('https://example.com/agent-registration.json');
await regTx.waitConfirmed();

// Get agent from specific chain
const agent = await sdk.getAgent('1:1234');  // Ethereum Mainnet

// Search feedback for agent on specific chain
const feedbacks = await sdk.searchFeedback({ agentId: '1:1234' });  // Ethereum Mainnet
const feedbacksDefault = await sdk.searchFeedback({ agentId: '11155111:1234' });  // Default chain

// Get reputation summary for agent on specific chain
const summary = await sdk.getReputationSummary('1:1234');  // Ethereum Mainnet
const summaryDefault = await sdk.getReputationSummary('1234');  // Uses default chain

// Search across multiple chains
const result = await sdk.searchAgents({
  active: true,
  chains: [1, 8453, 11155111, 84532, 137]  // Ethereum Mainnet, Base Mainnet, Ethereum Sepolia, Base Sepolia, Polygon Mainnet
});

// Search all configured chains
const allChainsResult = await sdk.searchAgents({
  active: true,
  chains: 'all'  // Searches all configured chains
});

// Multi-chain feedback-derived reputation search (unified search)
const reputationResult = await sdk.searchAgents(
  { chains: [1, 8453, 11155111, 84532, 137], feedback: { minValue: 80, includeRevoked: false } }
);

// Search all chains for agents with reputation (unified search)
const allChainsReputation = await sdk.searchAgents(
  { chains: 'all', feedback: { minValue: 80, includeRevoked: false } }
);

// Pagination has been removed; multi-chain results are returned as a flat list.

const sdk = new SDK({
  chainId: 11155111,  // Default chain; rpcUrl optional (built-in default used)
  rpcUrl: 'https://eth-sepolia.g.alchemy.com/v2/YOUR_KEY'  // optional override
});

// Uses default chain (11155111)
const agent = await sdk.getAgent('1234');  // Equivalent to "11155111:1234"

// Explicitly specify different chain
const agent = await sdk.getAgent('1:1234');  // Ethereum Mainnet

// Add OASF skills (with optional validation)
agent.addSkill('advanced_reasoning_planning/strategic_planning', true);
agent.addSkill('data_engineering/data_transformation_pipeline', true);

// Add OASF domains (with optional validation)
agent.addDomain('finance_and_business/investment_services', true);
agent.addDomain('technology/data_science/data_visualization', true);

// Remove skills/domains
agent.removeSkill('old_skill');
agent.removeDomain('old_domain');

const results = await sdk.searchAgents(filters?: SearchFilters, options?: SearchOptions);
// results: AgentSummary[]

export interface FeedbackFilters {
  hasFeedback?: boolean;
  hasNoFeedback?: boolean;
  includeRevoked?: boolean;
  minValue?: number;
  maxValue?: number;
  minCount?: number;
  maxCount?: number;
  fromReviewers?: string[];
  endpoint?: string; // substring match
  hasResponse?: boolean;
  tag1?: string;
  tag2?: string;
  tag?: string; // matches tag1 OR tag2
}

export interface SearchFilters {
  chains?: number[] | 'all';
  agentIds?: string[];

  name?: string; // substring
  description?: string; // substring

  owners?: string[];
  operators?: string[];

  hasRegistrationFile?: boolean;
  hasWeb?: boolean;
  hasMCP?: boolean;
  hasA2A?: boolean;
  hasOASF?: boolean;
  hasEndpoints?: boolean;

  webContains?: string;
  mcpContains?: string;
  a2aContains?: string;
  ensContains?: string;
  didContains?: string;

  walletAddress?: string;

  supportedTrust?: string[];
  a2aSkills?: string[];
  mcpTools?: string[];
  mcpPrompts?: string[];
  mcpResources?: string[];
  oasfSkills?: string[];
  oasfDomains?: string[];

  active?: boolean;
  x402support?: boolean;

  registeredAtFrom?: Date | string | number;
  registeredAtTo?: Date | string | number;
  updatedAtFrom?: Date | string | number;
  updatedAtTo?: Date | string | number;

  hasMetadataKey?: string;
  metadataValue?: { key: string; value: string };

  keyword?: string;
  feedback?: FeedbackFilters;
}

export interface SearchOptions {
  sort?: string[];           // e.g. ["averageValue:desc", "updatedAt:desc"]
  semanticMinScore?: number; // keyword searches only
  semanticTopK?: number;     // keyword searches only
}

export interface AgentSummary {
  chainId: number;
  agentId: string;
  name: string;
  image?: string;
  description: string;
  owners: string[];
  operators: string[];
  // Endpoint strings (present when advertised; not booleans)
  mcp?: string;
  a2a?: string;
  web?: string;
  email?: string;
  ens?: string;
  did?: string;
  walletAddress?: string;
  supportedTrusts: string[];
  a2aSkills: string[];
  mcpTools: string[];
  mcpPrompts: string[];
  mcpResources: string[];
  oasfSkills: string[];
  oasfDomains: string[];
  active: boolean;
  x402support: boolean;
  createdAt?: number;
  updatedAt?: number;
  lastActivity?: number;
  agentURI?: string;
  agentURIType?: string;
  feedbackCount?: number;
  averageValue?: number;
  semanticScore?: number;
  extras: Record<string, any>;
}