pwap/web/src/hooks/useDelegation.ts

import { useState, useEffect } from 'react';
import { usePolkadot } from '@/contexts/PolkadotContext';

export interface Delegate {
  id: string;
  address: string;
  name?: string;
  avatar?: string;
  reputation: number;
  successRate: number;
  totalDelegated: string;
  delegatorCount: number;
  activeProposals: number;
  categories: string[];
  description: string;
  performance: {
    proposalsCreated: number;
    proposalsPassed: number;
    participationRate: number;
  };
  conviction: number;
}

export interface UserDelegation {
  id: string;
  delegate: string;
  delegateAddress: string;
  amount: string;
  conviction: number;
  category?: string;
  tracks?: number[];
  blockNumber: number;
  status: 'active' | 'expired' | 'revoked';
}

export interface DelegationStats {
  activeDelegates: number;
  totalDelegated: string;
  avgSuccessRate: number;
  userDelegated: string;
}

export function useDelegation(userAddress?: string) {
  const { api, isConnected } = usePolkadot();
  const [delegates, setDelegates] = useState<Delegate[]>([]);
  const [userDelegations, setUserDelegations] = useState<UserDelegation[]>([]);
  const [stats, setStats] = useState<DelegationStats>({
    activeDelegates: 0,
    totalDelegated: '0',
    avgSuccessRate: 0,
    userDelegated: '0'
  });
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState<string | null>(null);

  useEffect(() => {
    if (!api || !isConnected) {
      setLoading(false);
      return;
    }

    const fetchDelegationData = async () => {
      try {
        setLoading(true);
        setError(null);

        // Fetch all voting delegations from democracy pallet
        const votingEntries = await api.query.democracy?.voting?.entries();
        const delegateMap = new Map<string, {
          totalDelegated: bigint;
          delegatorCount: number;
          conviction: number;
        }>();

        const userDelegationsList: UserDelegation[] = [];
        let totalDelegatedAmount = BigInt(0);
        let userTotalDelegated = BigInt(0);

        if (votingEntries) {
          votingEntries.forEach(([key, value]: [unknown, unknown]) => {
            const accountId = key.args[0].toString();
            const votingInfo = value.unwrap();

            if (votingInfo.isDelegating) {
              const delegation = votingInfo.asDelegating;
              const delegateAddress = delegation.target.toString();
              const balance = BigInt(delegation.balance.toString());
              const conviction = delegation.conviction.toNumber();

              // Track delegate totals
              const existing = delegateMap.get(delegateAddress) || {
                totalDelegated: BigInt(0),
                delegatorCount: 0,
                conviction: 0
              };
              delegateMap.set(delegateAddress, {
                totalDelegated: existing.totalDelegated + balance,
                delegatorCount: existing.delegatorCount + 1,
                conviction: Math.max(existing.conviction, conviction)
              });

              totalDelegatedAmount += balance;

              // Track user delegations
              if (userAddress && accountId === userAddress) {
                userDelegationsList.push({
                  id: `delegation-${accountId}-${delegateAddress}`,
                  delegate: delegateAddress.substring(0, 8) + '...',
                  delegateAddress,
                  amount: balance.toString(),
                  conviction,
                  blockNumber: Date.now(),
                  status: 'active'
                });
                userTotalDelegated += balance;
              }
            }
          });
        }

        // Build delegate list with performance metrics
        const delegatesList: Delegate[] = [];
        let totalSuccessRate = 0;

        for (const [address, data] of delegateMap.entries()) {
          // Fetch delegate's voting history
          const votingHistory = await api.query.democracy?.votingOf?.(address);
          let participationRate = 85; // Default
          let proposalsPassed = 0;
          let proposalsCreated = 0;

          if (votingHistory) {
            const votes = votingHistory.toJSON() as Record<string, unknown>;
            if (votes?.votes) {
              proposalsCreated = votes.votes.length;
              proposalsPassed = Math.floor(proposalsCreated * 0.85); // Estimate
              participationRate = proposalsCreated > 0 ? 90 : 85;
            }
          }

          const successRate = proposalsCreated > 0
            ? Math.floor((proposalsPassed / proposalsCreated) * 100)
            : 85;

          totalSuccessRate += successRate;

          delegatesList.push({
            id: address,
            address,
            name: `Delegate ${address.substring(0, 6)}`,
            reputation: Math.floor(Number(data.totalDelegated) / 1000000000000),
            successRate,
            totalDelegated: data.totalDelegated.toString(),
            delegatorCount: data.delegatorCount,
            activeProposals: Math.floor(Math.random() * 10) + 1,
            categories: ['Governance', 'Treasury'],
            description: `Active delegate with ${data.delegatorCount} delegators`,
            performance: {
              proposalsCreated,
              proposalsPassed,
              participationRate
            },
            conviction: data.conviction
          });
        }

        // Sort delegates by total delegated amount
        delegatesList.sort((a, b) =>
          BigInt(b.totalDelegated) > BigInt(a.totalDelegated) ? 1 : -1
        );

        // Calculate stats
        const avgSuccessRate = delegatesList.length > 0
          ? Math.floor(totalSuccessRate / delegatesList.length)
          : 0;

        setDelegates(delegatesList);
        setUserDelegations(userDelegationsList);
        setStats({
          activeDelegates: delegatesList.length,
          totalDelegated: totalDelegatedAmount.toString(),
          avgSuccessRate,
          userDelegated: userTotalDelegated.toString()
        });

      } catch (err) {
        if (import.meta.env.DEV) console.error('Error fetching delegation data:', err);
        setError(err instanceof Error ? err.message : 'Failed to fetch delegation data');
      } finally {
        setLoading(false);
      }
    };

    fetchDelegationData();

    // Subscribe to updates every 30 seconds
    const interval = setInterval(fetchDelegationData, 30000);
    return () => clearInterval(interval);
  }, [api, isConnected, userAddress]);

  const delegateVotes = async (
    targetAddress: string,
    conviction: number,
    amount: string
  ) => {
    if (!api || !userAddress) {
      throw new Error('API not connected or user address not provided');
    }

    try {
      const tx = api.tx.democracy.delegate(
        targetAddress,
        conviction,
        amount
      );

      return tx;
    } catch (err) {
      if (import.meta.env.DEV) console.error('Error creating delegation transaction:', err);
      throw err;
    }
  };

  const undelegateVotes = async () => {
    if (!api || !userAddress) {
      throw new Error('API not connected or user address not provided');
    }

    try {
      const tx = api.tx.democracy.undelegate();
      return tx;
    } catch (err) {
      if (import.meta.env.DEV) console.error('Error creating undelegate transaction:', err);
      throw err;
    }
  };

  return {
    delegates,
    userDelegations,
    stats,
    loading,
    error,
    delegateVotes,
    undelegateVotes
  };
}