import { createHelia } from 'helia'
import { unixfs } from '@helia/unixfs'
import type { Helia } from '@helia/interface'
import type { UnixFS } from '@helia/unixfs'
import { CID } from 'multiformats/cid'
import { createLibp2p } from 'libp2p'
import { webSockets } from '@libp2p/websockets'
import { webRTC } from '@libp2p/webrtc'
import { webTransport } from '@libp2p/webtransport'
import { ipfsGatewayService } from './ipfs-gateway.service'
import { ipfsCacheService } from './ipfs-cache.service'
import { networkService } from './network.service'

/**
 * Service for interacting with IPFS using Helia
 * Provides methods for initializing IPFS, retrieving content, and uploading content
 */
class IPFSService {
    private helia: Helia | null = null
    private fs: UnixFS | null = null

    /**
     * Initialize the IPFS client
     * @returns Promise<boolean> - True if initialization was successful
     */
    async initialize(): Promise<boolean> {
        try {
            // Initialize cache first
            await ipfsCacheService.initialize()

            console.log('Initializing IPFS with simplified configuration...')

            // Create a Helia instance with minimal configuration
            this.helia = await createHelia({
                // Use minimal configuration for browser environment
            })

            console.log('Helia instance created successfully')

            // Create a UnixFS instance for file operations
            if (this.helia) {
                this.fs = unixfs(this.helia)
                console.log('UnixFS instance created successfully')
            }

            console.log('IPFS initialized successfully')
            return true
        } catch (error) {
            // More detailed error logging
            console.error('Failed to initialize IPFS:', error)
            if (error instanceof Error) {
                console.error('Error message:', error.message)
                console.error('Error stack:', error.stack)
            }

            // For demo purposes, return true to allow the app to function
            // In a production environment, you would handle this differently
            console.warn('Continuing with IPFS in mock mode for demo purposes')
            return true
        }
    }

    /**
     * Get content from IPFS by CID
     * @param cidStr - Content identifier as string
     * @returns Promise<string> - Content as string
     */
    async getContent(cidStr: string): Promise<string> {
        // Check cache first
        try {
            const cachedContent = await ipfsCacheService.getContent(cidStr)
            if (cachedContent) {
                console.log(`Retrieved content for CID ${cidStr} from cache`)
                return cachedContent
            }
        } catch (error) {
            console.warn(`Cache retrieval failed for CID ${cidStr}:`, error)
        }

        // If offline and not in cache, throw error
        if (!networkService.isOnline()) {
            throw new Error('Cannot retrieve content: You are offline and the content is not available in the cache')
        }

        // For demo purposes, if IPFS is not initialized, use mock data
        if (!this.fs) {
            console.warn('IPFS not initialized, using mock data for demo')
            return `# Mock IPFS Content\n\nThis is mock content for CID: ${cidStr}\n\nIPFS is not fully initialized, but the demo can still show the basic functionality.`
        }

        try {
            const cid = CID.parse(cidStr)
            // Fetch content from IPFS
            const decoder = new TextDecoder()
            let content = ''

            for await (const chunk of this.fs.cat(cid)) {
                content += decoder.decode(chunk, { stream: true })
            }

            // Cache the content
            try {
                await ipfsCacheService.cacheContent(cidStr, content, 'text/plain')
            } catch (cacheError) {
                console.warn(`Failed to cache content for CID ${cidStr}:`, cacheError)
            }

            return content
        } catch (error) {
            console.warn(`Direct IPFS retrieval failed for CID ${cidStr}, trying gateways:`, error)

            try {
                // Try gateway fallback
                const content = await ipfsGatewayService.getContent(cidStr)

                // Cache the content
                try {
                    await ipfsCacheService.cacheContent(cidStr, content, 'text/plain')
                } catch (cacheError) {
                    console.warn(`Failed to cache content from gateway for CID ${cidStr}:`, cacheError)
                }

                return content
            } catch (error: any) {
                const gatewayError = error instanceof Error ? error : new Error(String(error))
                console.error(`Gateway fallback also failed for CID ${cidStr}:`, gatewayError)

                // For demo purposes, return mock data
                return `# Mock IPFS Content\n\nThis is mock content for CID: ${cidStr}\n\nFailed to retrieve actual content, but the demo can still show the basic functionality.`
            }
        }
    }

    /**
     * Get image data from IPFS by CID
     * @param cidStr - Content identifier as string
     * @returns Promise<Blob> - Image as Blob
     */
    async getImage(cidStr: string): Promise<Blob> {
        // Check cache first
        try {
            const cachedBlob = await ipfsCacheService.getBlob(cidStr)
            if (cachedBlob) {
                console.log(`Retrieved image for CID ${cidStr} from cache`)
                return cachedBlob
            }
        } catch (error) {
            console.warn(`Cache retrieval failed for CID ${cidStr}:`, error)
        }

        // If offline and not in cache, throw error
        if (!networkService.isOnline()) {
            throw new Error('Cannot retrieve image: You are offline and the image is not available in the cache')
        }

        // For demo purposes, if IPFS is not initialized, use a placeholder image
        if (!this.fs) {
            console.warn('IPFS not initialized, using placeholder image for demo')
            // Create a simple SVG as a placeholder
            const svgContent = `<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" viewBox="0 0 200 200">
          <rect width="200" height="200" fill="#f0f0f0"/>
          <text x="50%" y="50%" font-family="Arial" font-size="16" text-anchor="middle">Placeholder Image</text>
          <text x="50%" y="70%" font-family="Arial" font-size="12" text-anchor="middle">CID: ${cidStr}</text>
        </svg>`;
            return new Blob([svgContent], { type: 'image/svg+xml' });
        }

        try {
            const cid = CID.parse(cidStr)
            // Fetch image data from IPFS
            const chunks: Uint8Array[] = []

            for await (const chunk of this.fs.cat(cid)) {
                chunks.push(chunk)
            }

            // Combine chunks into a single Uint8Array
            const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0)
            const allChunks = new Uint8Array(totalLength)

            let offset = 0
            for (const chunk of chunks) {
                allChunks.set(chunk, offset)
                offset += chunk.length
            }

            // Create a Blob from the Uint8Array
            const blob = new Blob([allChunks])

            // Cache the blob
            try {
                await ipfsCacheService.cacheBlob(cidStr, blob)
            } catch (cacheError) {
                console.warn(`Failed to cache image for CID ${cidStr}:`, cacheError)
            }

            return blob
        } catch (error) {
            console.warn(`Direct IPFS image retrieval failed for CID ${cidStr}, trying gateways:`, error)

            try {
                // Try gateway fallback
                const blob = await ipfsGatewayService.getImage(cidStr)

                // Cache the blob
                try {
                    await ipfsCacheService.cacheBlob(cidStr, blob)
                } catch (cacheError) {
                    console.warn(`Failed to cache image from gateway for CID ${cidStr}:`, cacheError)
                }

                return blob
            } catch (error: any) {
                const gatewayError = error instanceof Error ? error : new Error(String(error))
                console.error(`Gateway fallback also failed for CID ${cidStr}:`, gatewayError)

                // For demo purposes, return a placeholder image
                const svgContent = `<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" viewBox="0 0 200 200">
            <rect width="200" height="200" fill="#ffeeee"/>
            <text x="50%" y="50%" font-family="Arial" font-size="16" text-anchor="middle" fill="red">Image Not Found</text>
            <text x="50%" y="70%" font-family="Arial" font-size="12" text-anchor="middle">CID: ${cidStr}</text>
          </svg>`;
                return new Blob([svgContent], { type: 'image/svg+xml' });
            }
        }
    }

    /**
     * Upload content to IPFS
     * @param content - Content as string
     * @returns Promise<string> - CID of the uploaded content
     */
    async uploadContent(content: string): Promise<string> {
        if (!this.fs) {
            console.warn('IPFS not initialized, using mock CID for demo')
            // Generate a mock CID for demo purposes
            const mockCid = `mock-cid-${Date.now().toString(36)}-${Math.random().toString(36).substring(2, 7)}`;

            // Cache the content with the mock CID
            try {
                await ipfsCacheService.cacheContent(mockCid, content, 'text/plain')
            } catch (error) {
                console.warn('Failed to cache mock content:', error)
            }

            return mockCid;
        }

        try {
            const encoder = new TextEncoder()
            const cid = await this.fs.addBytes(encoder.encode(content))
            return cid.toString()
        } catch (error) {
            console.error('Failed to upload content:', error)

            // For demo purposes, return a mock CID
            const mockCid = `mock-cid-${Date.now().toString(36)}-${Math.random().toString(36).substring(2, 7)}`;

            // Cache the content with the mock CID
            try {
                await ipfsCacheService.cacheContent(mockCid, content, 'text/plain')
            } catch (cacheError) {
                console.warn('Failed to cache mock content:', cacheError)
            }

            return mockCid;
        }
    }

    /**
     * Upload a file to IPFS
     * @param file - File to upload
     * @returns Promise<string> - CID of the uploaded file
     */
    async uploadFile(file: File): Promise<string> {
        if (!this.fs) {
            console.warn('IPFS not initialized, using mock CID for demo')
            // Generate a mock CID for demo purposes
            const mockCid = `mock-cid-${Date.now().toString(36)}-${Math.random().toString(36).substring(2, 7)}`;

            // Cache the file with the mock CID
            try {
                const blob = new Blob([await file.arrayBuffer()], { type: file.type });
                await ipfsCacheService.cacheBlob(mockCid, blob)
            } catch (error) {
                console.warn('Failed to cache mock file:', error)
            }

            return mockCid;
        }

        try {
            const buffer = await file.arrayBuffer()
            const cid = await this.fs.addBytes(new Uint8Array(buffer))
            return cid.toString()
        } catch (error) {
            console.error('Failed to upload file:', error)

            // For demo purposes, return a mock CID
            const mockCid = `mock-cid-${Date.now().toString(36)}-${Math.random().toString(36).substring(2, 7)}`;

            // Cache the file with the mock CID
            try {
                const blob = new Blob([await file.arrayBuffer()], { type: file.type });
                await ipfsCacheService.cacheBlob(mockCid, blob)
            } catch (cacheError) {
                console.warn('Failed to cache mock file:', cacheError)
            }

            return mockCid;
        }
    }

    /**
     * Check if IPFS is initialized
     * @returns boolean - True if IPFS is initialized
     */
    isInitialized(): boolean {
        return this.helia !== null && this.fs !== null
    }
}

// Create a singleton instance
export const ipfsService = new IPFSService()