import { TxBuilder } from '@hydra-sdk/transaction'

// Hydra transactions có fees khác với Cardano mainnet
const txBuilder = new TxBuilder({ 
  isHydra: true, 
  params: { 
    minFeeA: 0, // Hydra có fee structure khác
    minFeeB: 0 
  } 
})

// Build transaction như bình thường
const tx = await txBuilder
  .setInputs(utxos)
  .addOutput({
    address: recipientAddress,
    amount: [{ unit: 'lovelace', quantity: '1000000' }]
  })
  .setChangeAddress(changeAddress)
  .complete()

console.log('Hydra Transaction:', tx.to_hex())

import { HydraBridge, HexcoreConnector } from '@hydra-sdk/bridge'

// Socket.IO connection với authentication
const bridge = new HydraBridge({
  connector: new HexcoreConnector(
    'wss://alpha-v1-api.hexcore.io.vn', 
    { 
      socketIoOptions: { 
        auth: { token: 'your-jwt-token-here' } 
      } 
    }
  )
})

// Event handlers theo patterns thực tế
bridge.events.on('onConnected', () => {
  console.log('✅ Connected to Hydra Head')
})

bridge.events.on('onDisconnected', () => {
  console.log('❌ Disconnected from Hydra Head')
})

bridge.events.on('onHeadIsOpen', (data) => {
  console.log('🚀 Hydra Head is open:', data)
})

bridge.events.on('onHeadIsClosed', (data) => {
  console.log('🔒 Hydra Head is closed:', data)
})

bridge.events.on('onTxValid', (txHash) => {
  console.log('✅ Transaction valid:', txHash)
})

bridge.events.on('onTxInvalid', (txHash, reason) => {
  console.log('❌ Transaction invalid:', txHash, reason)
})

// Connect và cleanup
await bridge.connect()

// Cleanup trong Vue/React lifecycle
// onBeforeUnmount(() => bridge?.disconnect())

// Pattern từ nodejs-playground cho Hydra API calls
import { convertUTxOObjectToUTxO, UTxO } from '@hydra-sdk/core'
import axios from 'axios'

class HydraHexcoreApi {
  private instance = axios.create({
    baseURL: 'https://alpha-v1-api.hexcore.io.vn',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${process.env.HEXCORE_API_TOKEN}`
    }
  })

  async queryAddressUTxO(address: string): Promise<UTxO[]> {
    try {
      const response = await this.instance.get(`hydra-main/utxo/${address}`)

      if (response.data.data) {
        return convertUTxOObjectToUTxO(response.data.data)
      } else {
        throw new Error('No UTxO data found in Hydra response')
      }
    } catch (error) {
      console.error('Error querying Hydra UTxO:', error)
      throw error
    }
  }

  async submitHydraTx(cborHex: string) {
    try {
      const response = await this.instance.post('/hydra-main/tx', {
        cborHex
      })
      return response.data.txHash
    } catch (error) {
      console.error('Error submitting to Hydra:', error)
      throw error
    }
  }
}

// Usage
const hydraApi = new HydraHexcoreApi()
const utxos = await hydraApi.queryAddressUTxO(walletAddress)

// Pattern cho environment configuration
import { NETWORK_ID } from '@hydra-sdk/core'

const getNetworkConfig = (isHydra: boolean = false) => {
  if (isHydra) {
    return {
      networkId: NETWORK_ID.PREPROD, // Hydra sử dụng preprod network
      apiEndpoint: 'https://alpha-v1-api.hexcore.io.vn',
      socketEndpoint: 'wss://alpha-v1-api.hexcore.io.vn',
      isHydra: true,
      txParams: {
        minFeeA: 0,
        minFeeB: 0
      }
    }
  } else {
    return {
      networkId: NETWORK_ID.PREPROD,
      apiEndpoint: 'https://preprod.blockfrost.io/api/v0',
      socketEndpoint: null,
      isHydra: false,
      txParams: {
        minFeeA: 44,
        minFeeB: 155381
      }
    }
  }
}

// Usage trong application
const config = getNetworkConfig(process.env.USE_HYDRA === 'true')
const txBuilder = new TxBuilder({ 
  isHydra: config.isHydra, 
  params: config.txParams 
})

import { AppWallet, NETWORK_ID } from '@hydra-sdk/core'
import { TxBuilder } from '@hydra-sdk/transaction'
import { HydraBridge, HexcoreConnector } from '@hydra-sdk/bridge'

class HydraWalletManager {
  private wallet: AppWallet
  private bridge: HydraBridge
  private hydraApi: HydraHexcoreApi

  constructor(mnemonic: string[], jwtToken: string) {
    this.wallet = new AppWallet({
      key: { type: 'mnemonic', words: mnemonic },
      networkId: NETWORK_ID.PREPROD
    })

    this.bridge = new HydraBridge({
      connector: new HexcoreConnector(
        'wss://alpha-v1-api.hexcore.io.vn',
        { socketIoOptions: { auth: { token: jwtToken } } }
      )
    })

    this.hydraApi = new HydraHexcoreApi()
    this.setupEventHandlers()
  }

  private setupEventHandlers() {
    this.bridge.events.on('onConnected', () => {
      console.log('🔗 Hydra Bridge Connected')
    })

    this.bridge.events.on('onTxValid', (txHash) => {
      console.log('✅ Hydra TX Valid:', txHash)
    })
  }

  async sendHydraTransaction(recipientAddress: string, amountLovelace: string) {
    try {
      // 1. Connect to Hydra if not connected
      if (!this.bridge.connected) {
        await this.bridge.connect()
      }

      // 2. Query UTxOs từ Hydra
      const walletAddress = this.wallet.getAccount().baseAddressBech32
      const utxos = await this.hydraApi.queryAddressUTxO(walletAddress)

      // 3. Build Hydra transaction
      const txBuilder = new TxBuilder({ 
        isHydra: true, 
        params: { minFeeA: 0, minFeeB: 0 } 
      })

      const tx = await txBuilder
        .setInputs(utxos)
        .addOutput({
          address: recipientAddress,
          amount: [{ unit: 'lovelace', quantity: amountLovelace }]
        })
        .setChangeAddress(walletAddress)
        .complete()

      // 4. Sign transaction
      const signedTx = await this.wallet.signTx(tx.to_hex())

      // 5. Submit to Hydra
      const txHash = await this.hydraApi.submitHydraTx(signedTx)
      
      console.log('🚀 Hydra Transaction Submitted:', txHash)
      return txHash

    } catch (error) {
      console.error('❌ Hydra Transaction Error:', error)
      throw error
    }
  }

  async disconnect() {
    await this.bridge.disconnect()
  }
}

// Usage
const hydraManager = new HydraWalletManager(
  'your mnemonic words here'.split(' '),
  'your-jwt-token'
)

await hydraManager.sendHydraTransaction(
  'addr1qx2fxv2umyhttkxyxp8x0dlpdt3k6cwng5pxj3jhsydzer',
  '1000000'
)

// ❌ Sai - dùng Cardano params cho Hydra
const txBuilder = new TxBuilder({}) // Default Cardano params

// ✅ Đúng - dùng Hydra params
const txBuilder = new TxBuilder({ 
  isHydra: true, 
  params: { minFeeA: 0, minFeeB: 0 } 
})

// ❌ Sai - dùng plain WebSocket
const ws = new WebSocket('wss://alpha-v1-api.hexcore.io.vn')

// ✅ Đúng - dùng Socket.IO với auth
const bridge = new HydraBridge({
  connector: new HexcoreConnector(url, {
    socketIoOptions: { 
      auth: { token: 'your-jwt-token' } 
    }
  })
})

// ✅ Proper cleanup
class HydraComponent {
  private bridge: HydraBridge

  async mounted() {
    this.bridge = new HydraBridge({...})
    await this.bridge.connect()
  }

  async beforeUnmount() {
    // Quan trọng: cleanup connection
    await this.bridge?.disconnect()
  }
}