using Android.Content;
using Android.Webkit;
using Microsoft.Maui.Controls;
using Microsoft.Maui.Handlers;
using Microsoft.Maui.Platform;
using System;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Threading.Tasks;
using Xamarin.Forms.Clinical6.UI.Controls;

namespace MAUI.Clinical6.Platforms.Android.Renders
{
    public class PdfWebViewerHandler : ViewHandler<PdfWebViewer, global::Android.Webkit.WebView>
    {
        private static readonly WebClient _webClient = new WebClient();
        private WebViewClientDelegate _webDelegate;

        public static IPropertyMapper<PdfWebViewer, PdfWebViewerHandler> Mapper =
            new PropertyMapper<PdfWebViewer, PdfWebViewerHandler>(ViewHandler.ViewMapper)
            {
                [nameof(PdfWebViewer.Uri)] = MapUri
            };

        public PdfWebViewerHandler() : base(Mapper) { }

        protected override global::Android.Webkit.WebView CreatePlatformView()
        {
            var webView = new global::Android.Webkit.WebView(Context);

            // Enhanced settings for MAUI compatibility
            webView.Settings.JavaScriptEnabled = true;
            webView.Settings.AllowFileAccess = true;
            webView.Settings.AllowContentAccess = true;
            webView.Settings.AllowUniversalAccessFromFileURLs = true;
            webView.Settings.AllowFileAccessFromFileURLs = true;
            webView.Settings.DomStorageEnabled = true;
            webView.Settings.MixedContentMode = MixedContentHandling.AlwaysAllow;

            // Add WebChromeClient for JavaScript console logging
            webView.SetWebChromeClient(new DebugWebChromeClient());

            return webView;
        }

        protected override void ConnectHandler(global::Android.Webkit.WebView platformView)
        {
            base.ConnectHandler(platformView);

            if (VirtualView != null && platformView != null)
            {
                _webDelegate = new WebViewClientDelegate(VirtualView);
                platformView.SetWebViewClient(_webDelegate);

                if (!string.IsNullOrEmpty(VirtualView.Uri))
                {
                    CheckLocalDownload(GetFileNameFromUri());
                }
            }
        }

        private static void MapUri(PdfWebViewerHandler handler, PdfWebViewer view)
        {
            handler?.CheckLocalDownload(handler.GetFileNameFromUri());
        }

        private string GetFileNameFromUri()
        {
            if (VirtualView != null && !string.IsNullOrEmpty(VirtualView.Uri))
            {
                var uri = new Uri(VirtualView.Uri);
                return Path.GetFileName(uri.AbsolutePath);
            }

            return $"{Guid.NewGuid()}.pdf";
        }

        private async void CheckLocalDownload(string fileName)
        {
            try
            {
                var fileDownloaded = await DownloadFile(VirtualView.Uri, fileName);
                if (fileDownloaded)
                {
                    await LoadUrl(fileName);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"CheckLocalDownload Exception: {ex}");
            }
        }

        private async Task<bool> DownloadFile(string uri, string filename)
        {
            try
            {
                string documentsPath = Path.Combine(FileSystem.AppDataDirectory, "Documents");

                if (!Directory.Exists(documentsPath))
                    Directory.CreateDirectory(documentsPath);

                string localPath = Path.Combine(documentsPath, filename);

                // Check if file already exists
                if (File.Exists(localPath))
                {
                    var fileInfo = new FileInfo(localPath);
                    if (fileInfo.Length > 0)
                        return true;
                }

                // Use HttpClient instead of WebClient
                using var httpClient = new HttpClient();
                httpClient.Timeout = TimeSpan.FromMinutes(5);

                var response = await httpClient.GetAsync(uri);

                if (response.IsSuccessStatusCode)
                {
                    var content = await response.Content.ReadAsByteArrayAsync();
                    await File.WriteAllBytesAsync(localPath, content);
                    return File.Exists(localPath);
                }

                return false;
            }
            catch (Exception exc)
            {
                System.Diagnostics.Debug.WriteLine($"Download failed: {exc.Message}");
                return false;
            }
        }

        private async Task LoadUrl(string fileName)
        {
            string documentsPath = Path.Combine(FileSystem.AppDataDirectory, "Documents");
            string localPath = Path.Combine(documentsPath, fileName);

            if (!File.Exists(localPath))
            {
                await ShowErrorMessage("File not found", "The requested file could not be located.");
                return;
            }

            string fileType = Path.GetExtension(localPath).Replace(".", string.Empty).ToLower();

            if (PlatformView == null || VirtualView == null)
                return;

            try
            {
                switch (fileType)
                {
                    case "pdf":
                        // Use PDF.js viewer
                        if (await CheckAssetExists("pdfjs/web/viewer.html"))
                        {
                            await LoadPdfFile(localPath, fileName);
                        }
                        else
                        {
                            await ShowErrorMessage("PDF Viewer Not Available", "PDF.js is not installed.");
                        }
                        break;

                    case "jpg":
                    case "jpeg":
                    case "png":
                    case "gif":
                    case "bmp":
                    case "webp":
                        await LoadImageFile(localPath);
                        break;

                    case "txt":
                        //await LoadTextFile(localPath); // keep existing text loader if you have one
                        break;

                    default:
                        await ShowErrorMessage("Unsupported File Type", $"Cannot display . {fileType} files in this viewer.");
                        break;
                }
            }
            catch (Exception ex)
            {
                await ShowErrorMessage("Loading Error", $"An error occurred while loading the file: {ex.Message}");
            }
        }

        private string CreateCustomPdfViewer(string pdfPath, string fileName)
        {
            string html = $@"
<!DOCTYPE html>
<html style=""height: 100%; margin: 0; padding: 0;"">
<head>
    <meta charset=""utf-8"">
    <meta name=""viewport"" content=""width=device-width, initial-scale=1.0, maximum-scale=5.0, user-scalable=yes"">
    <title>{fileName}</title>
    <script src=""file:///android_asset/pdfjs/build/pdf.js""></script>
    <style>
        * {{ margin: 0; padding: 0; box-sizing: border-box; }}
        
        html {{
            height: 100%;
            width: 100%;
            position: fixed;
            overflow: hidden;
        }}
        
        body {{
            background: #404040;
            font-family: Arial, sans-serif;
            height: 100%;
            width: 100%;
            position: relative;
            overflow: hidden;
            display: flex;
            flex-direction: column;
        }}
        
        #loading {{
            position: fixed;
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
            color: white;
            text-align: center;
            font-size: 18px;
            z-index: 2000;
        }}
        
        #toolbar {{
            flex-shrink: 0;
            height: 50px;
            background: rgba(50, 54, 57, 0.95);
            color: white;
            padding: 8px;
            display: none;
            z-index: 1000;
            box-shadow: 0 2px 5px rgba(0,0,0,0.3);
        }}
        
        #toolbar-content {{
            display: flex;
            align-items: center;
            justify-content: space-between;
            gap: 10px;
            height: 100%;
        }}
        
        #toolbar button {{
            background: #474B4F;
            color: white;
            border: none;
            padding: 8px 12px;
            border-radius:  4px;
            cursor:  pointer;
            font-size:  14px;
            min-width: 40px;
        }}
        #toolbar button:active {{
            background: #5A5F63;
        }}
        #toolbar button:disabled {{
            opacity: 0.5;
            cursor: not-allowed;
        }}
        #page-info {{
            font-size: 14px;
            white-space: nowrap;
        }}
        
        #container {{
            flex: 1;
            overflow-y: auto;
            overflow-x: hidden;
            padding: 10px;
            display: none;
            -webkit-overflow-scrolling: touch;
        }}
        
        .page {{
            margin: 10px auto;
            background: white;
            box-shadow: 0 0 10px rgba(0,0,0,0.5);
            display: block;
        }}
        canvas {{
            display: block;
            max-width: 100%;
            height: auto;
        }}
    </style>
</head>
<body>
    <div id=""loading"">Loading PDF...</div>
    <div id=""toolbar"">
        <div id=""toolbar-content"">
            <div id=""page-info""></div>
            <div>
                <button id=""page-up"" title=""Previous Page"">↑</button>
                <button id=""page-down"" title=""Next Page"">↓</button>
            </div>
        </div>
    </div>
    <div id=""container""></div>
    <script>
        console.log('Starting PDF.js viewer');
        
        // Configure PDF.js worker
        pdfjsLib.GlobalWorkerOptions.workerSrc = 'file:///android_asset/pdfjs/build/pdf.worker.js';
        
        // State management
        let pdfDoc = null;
        let pageCanvases = [];
        let baseScale = 1.5;
        
        // Load PDF
        const pdfPath = 'file://{pdfPath}';
        console.log('📄 Loading PDF from:', pdfPath);
        
        pdfjsLib.getDocument(pdfPath).promise.then(function(pdf) {{
            console.log('PDF loaded. Pages:', pdf.numPages);
            pdfDoc = pdf;
            
            document.getElementById('loading').style.display = 'none';
            const toolbar = document.getElementById('toolbar');
            toolbar.style.display = 'block';
            const container = document.getElementById('container');
            container.style.display = 'block';
            
            updatePageInfo();
            
            // Calculate optimal scale to fit page width
            return pdf.getPage(1).then(function(firstPage) {{
                return new Promise(function(resolve) {{
                    setTimeout(function() {{
                        const containerWidth = container.clientWidth - 20;
                        const viewport = firstPage.getViewport({{ scale: 1.0 }});
                        
                        console.log('Container width:', containerWidth);
                        console.log('PDF width at scale 1.0:', viewport.width);
                        
                        // Calculate base scale to fit page width
                        if (containerWidth > 100 && viewport.width > 0) {{
                            baseScale = containerWidth / viewport.width;
                        }} else {{
                            baseScale = 1.5;
                            console.log('Using default scale');
                        }}
                        
                        // Ensure scale is within reasonable bounds
                        if (baseScale < 1.0) baseScale = 1.0;
                        if (baseScale > 3.0) baseScale = 3.0;
                        
                        console.log('Final base scale:', baseScale);
                        
                        resolve();
                    }}, 100);
                }});
            }}).then(function() {{
                // Render all pages
                const renderPromises = [];
                for (let pageNum = 1; pageNum <= pdf.numPages; pageNum++) {{
                    renderPromises.push(
                        pdf.getPage(pageNum).then(function(page) {{
                            console.log('Rendering page', pageNum);
                            
                            const viewport = page.getViewport({{ scale: baseScale }});
                            
                            const canvas = document.createElement('canvas');
                            canvas.className = 'page';
                            canvas.dataset.pageNum = pageNum;
                            const context = canvas.getContext('2d');
                            
                            canvas.width = viewport.width;
                            canvas.height = viewport.height;
                            
                            container.appendChild(canvas);
                            pageCanvases.push({{ canvas, page }});
                            
                            return page.render({{
                                canvasContext: context,
                                viewport: viewport
                            }}).promise.then(function() {{
                                console.log('Page', pageNum, 'rendered');
                            }});
                        }})
                    );
                }}
                
                return Promise.all(renderPromises);
            }}).then(function() {{
                console.log('All pages rendered successfully');
                setupToolbar();
            }});
        }}).catch(function(error) {{
            console.error('Error:', error);
            document.getElementById('loading').innerHTML = 'Error loading PDF:<br>' + error.message;
        }});
        
        function updatePageInfo() {{
            if (pdfDoc) {{
                document.getElementById('page-info').textContent = `Page 1 of ${{pdfDoc.numPages}}`;
            }}
        }}
        
        function setupToolbar() {{
            const container = document.getElementById('container');
            
            // Page navigation buttons
            document.getElementById('page-up').addEventListener('click', function() {{
                container.scrollBy({{ top: -container.clientHeight * 0.9, behavior: 'smooth' }});
            }});
            
            document.getElementById('page-down').addEventListener('click', function() {{
                container.scrollBy({{ top: container.clientHeight * 0.9, behavior: 'smooth' }});
            }});
            
            // Update current page indicator on scroll
            container.addEventListener('scroll', updateCurrentPage);
        }}
        
        function updateCurrentPage() {{
            const container = document.getElementById('container');
            const scrollTop = container.scrollTop + 100;
            
            let currentPage = 1;
            const canvases = container.querySelectorAll('canvas');
            
            for (let i = 0; i < canvases.length; i++) {{
                if (canvases[i].offsetTop <= scrollTop) {{
                    currentPage = i + 1;
                }}
            }}
            
            if (pdfDoc) {{
                document.getElementById('page-info').textContent = `Page ${{currentPage}} of ${{pdfDoc.numPages}}`;
            }}
        }}
    </script>
</body>
</html>";

            return html;
        }

        private async Task<bool> CheckAssetExists(string assetPath)
        {
            try
            {
                using var stream = Context.Assets.Open(assetPath);
                return stream != null;
            }
            catch
            {
                return false;
            }
        }

        private async Task LoadPdfFile(string localPath, string fileName)
        {
            System.Diagnostics.Debug.WriteLine($"📄 LoadPdfFile called for:  {fileName}");
            System.Diagnostics.Debug.WriteLine($"📁 Local path: {localPath}");

            try
            {
                // Copy PDF to a location accessible to PDF.js
                string cacheDir = Context.CacheDir.AbsolutePath;
                string pdfCacheDir = Path.Combine(cacheDir, "pdfs");

                if (!Directory.Exists(pdfCacheDir))
                {
                    Directory.CreateDirectory(pdfCacheDir);
                    System.Diagnostics.Debug.WriteLine($"✅ Created cache directory: {pdfCacheDir}");
                }

                string cachedPdfPath = Path.Combine(pdfCacheDir, fileName);
                File.Copy(localPath, cachedPdfPath, true);

                System.Diagnostics.Debug.WriteLine($"✅ PDF copied to cache: {cachedPdfPath}");
                System.Diagnostics.Debug.WriteLine($"📊 File size: {new FileInfo(cachedPdfPath).Length} bytes");

                // Create custom PDF viewer HTML
                string customHtml = CreateCustomPdfViewer(cachedPdfPath, fileName);

                System.Diagnostics.Debug.WriteLine($"Loading custom PDF.js viewer");

                PlatformView.LoadDataWithBaseURL("file:///android_asset/", customHtml, "text/html", "UTF-8", null);
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine($"PDF.js failed: {ex.Message}");
                System.Diagnostics.Debug.WriteLine($"Stack trace: {ex.StackTrace}");
                await ShowErrorMessage("PDF Error", $"Failed to load PDF: {ex.Message}");
            }
        }

        private async Task LoadImageFile(string imagePath)
        {
            try
            {
                byte[] imageBytes = await File.ReadAllBytesAsync(imagePath);
                string base64 = Convert.ToBase64String(imageBytes);
                string extension = Path.GetExtension(imagePath).ToLower();

                string mimeType = extension switch
                {
                    ".jpg" or ".jpeg" => "image/jpeg",
                    ".png" => "image/png",
                    ".gif" => "image/gif",
                    ".bmp" => "image/bmp",
                    ".webp" => "image/webp",
                    _ => "image/jpeg"
                };

                string html = $@"
<!DOCTYPE html>
<html style=""height: 100%; margin: 0; padding: 0;"">
<head>
    <meta name='viewport' content='width=device-width, initial-scale=1.0, maximum-scale=5.0, user-scalable=yes'>
    <style>
        * {{ margin: 0; padding: 0; box-sizing: border-box; }}
        html {{ 
            height: 100%;
            width: 100%;
            position: fixed;
            overflow: hidden;
        }}
        body {{ 
            background: #f0f0f0; 
            display: flex; 
            justify-content: center;
            align-items: center;
            padding: 10px;
            width: 100%;
            height: 100%;
            position: relative;
        }}
        img {{ 
            max-width: 100%; 
            max-height: 100%; 
            object-fit: contain;
            border: 1px solid #ddd;
            background: white;
        }}
    </style>
</head>
<body>
    <img src='data:{mimeType};base64,{base64}' alt='Image' />
</body>
</html>";

                PlatformView.LoadDataWithBaseURL("file:///android_asset/", html, "text/html", "UTF-8", null);
            }
            catch (Exception ex)
            {
                await ShowErrorMessage("Image Error", $"Failed to load image file: {ex.Message}");
            }
        }

        private async Task ShowErrorMessage(string title, string message)
        {
            string html = $@"<html><body style='text-align: center;padding:40px;background:#f5f5f5;'>
        <div style='background: white;padding:30px;border-radius:8px;'>
        <h2 style='color:#e74c3c;'>{title}</h2>
        <p>{message}</p>
        </div></body></html>";

            PlatformView.LoadDataWithBaseURL(null, html, "text/html", "UTF-8", null);
        }

        private class WebViewClientDelegate : WebViewClient
        {
            private readonly PdfWebViewer _pdfWebViewer;

            public WebViewClientDelegate(PdfWebViewer pdfWebViewer)
            {
                _pdfWebViewer = pdfWebViewer;
            }

            public override void OnPageStarted(global::Android.Webkit.WebView view, string url, global::Android.Graphics.Bitmap favicon)
            {
                base.OnPageStarted(view, url, favicon);
                System.Diagnostics.Debug.WriteLine($"🔄 Page started: {url}");
            }

            public override void OnPageFinished(global::Android.Webkit.WebView view, string url)
            {
                base.OnPageFinished(view, url);
                System.Diagnostics.Debug.WriteLine($"Page finished: {url}");

                // Check if PDF.js viewer loaded
                if (url.Contains("pdfjs/web/viewer.html"))
                {
                    // Inject JavaScript to check PDF.js status
                    string checkScript = @"
                        setTimeout(function() {
                            if (window.PDFViewerApplication) {
                                console.log('PDFViewerApplication exists');
                                console.log('PDF loaded:', window.PDFViewerApplication.pdfDocument !== null);
                                if (window.PDFViewerApplication.pdfDocument) {
                                    console.log('Number of pages:', window.PDFViewerApplication.pdfDocument.numPages);
                                }
                                console.log('Viewer initialized:', window.PDFViewerApplication.initialized);
                            } else {
                                console.log('PDFViewerApplication not found');
                            }
                        }, 2000);
                    ";

                    view.EvaluateJavascript(checkScript, null);
                    System.Diagnostics.Debug.WriteLine($"Injected PDF.js status check");
                }

                _pdfWebViewer?.OnUrlLoaded();
            }

            public override void OnReceivedError(global::Android.Webkit.WebView view, IWebResourceRequest request, WebResourceError error)
            {
                base.OnReceivedError(view, request, error);
                System.Diagnostics.Debug.WriteLine($"WebView Error: {error.Description} for URL: {request.Url}");
            }
        }

        private class DebugWebChromeClient : WebChromeClient
        {
            public override bool OnConsoleMessage(ConsoleMessage consoleMessage)
            {
                System.Diagnostics.Debug.WriteLine($"📋 JS Console [{consoleMessage.InvokeMessageLevel()}]: {consoleMessage.Message()} at {consoleMessage.SourceId()}:{consoleMessage.LineNumber()}");
                return base.OnConsoleMessage(consoleMessage);
            }
        }
    }
}