"""
Browser cookie import functionality
"""

import os
import platform
from typing import Dict, Any

from ..config import session, logger, BROWSER_COOKIE3_AVAILABLE


async def import_cookies_from_browser(browser: str, domain: str = None, verbose: bool = True) -> dict:
    """Import cookies from specified browser with comprehensive diagnostics."""
    if not BROWSER_COOKIE3_AVAILABLE:
        return {
            "browser": browser,
            "cookies_imported": 0,
            "error": "browser-cookie3 not available"
        }
    
    import browser_cookie3
    
    # Initialize diagnostic information
    diagnostics = {
        "library_available": True,
        "browser_supported": False,
        "browser_found": False,
        "cookie_file_path": None,
        "total_cookies_in_file": 0,
        "domain_matches": 0,
        "access_error": None,
        "system_info": {
            "platform": platform.system(),
            "architecture": platform.architecture()[0],
            "python_version": platform.python_version()
        }
    }
    
    supported_browsers = ['chrome', 'firefox', 'edge', 'safari']
    browser_lower = browser.lower()
    
    if browser_lower not in supported_browsers:
        return {
            "browser": browser,
            "domain": domain or "all domains",
            "cookies_imported": 0,
            "diagnostics": {
                **diagnostics,
                "error_details": f"Unsupported browser: {browser}",
                "supported_browsers": supported_browsers
            },
            "recommendations": [
                f"Use one of supported browsers: {', '.join(supported_browsers)}",
                "Check browser name spelling",
                "Ensure browser is properly installed"
            ]
        }
    
    diagnostics["browser_supported"] = True
    
    # Check common browser installation paths
    browser_paths = {
        "chrome": {
            "Windows": [
                os.path.expanduser("~\\AppData\\Local\\Google\\Chrome\\User Data"),
                os.path.expanduser("~\\AppData\\Local\\Chromium\\User Data")
            ],
            "Darwin": [
                os.path.expanduser("~/Library/Application Support/Google/Chrome"),
                os.path.expanduser("~/Library/Application Support/Chromium")
            ],
            "Linux": [
                os.path.expanduser("~/.config/google-chrome"),
                os.path.expanduser("~/.config/chromium")
            ]
        },
        "firefox": {
            "Windows": [os.path.expanduser("~\\AppData\\Roaming\\Mozilla\\Firefox\\Profiles")],
            "Darwin": [os.path.expanduser("~/Library/Application Support/Firefox/Profiles")],
            "Linux": [os.path.expanduser("~/.mozilla/firefox")]
        },
        "edge": {
            "Windows": [os.path.expanduser("~\\AppData\\Local\\Microsoft\\Edge\\User Data")],
            "Darwin": [os.path.expanduser("~/Library/Application Support/Microsoft Edge")],
            "Linux": [os.path.expanduser("~/.config/microsoft-edge")]
        },
        "safari": {
            "Darwin": [os.path.expanduser("~/Library/Cookies")]
        }
    }
    
    # Check if browser data directory exists
    system = platform.system()
    browser_data_paths = browser_paths.get(browser_lower, {}).get(system, [])
    
    for path in browser_data_paths:
        if os.path.exists(path):
            diagnostics["browser_found"] = True
            diagnostics["cookie_file_path"] = path
            break
    
    try:
        # Get cookies based on browser
        all_cookies = []
        cookies_before_import = len(session.cookies)
        
        if browser_lower == 'chrome':
            cookies = browser_cookie3.chrome(domain_name=domain)
        elif browser_lower == 'firefox':
            cookies = browser_cookie3.firefox(domain_name=domain)
        elif browser_lower == 'edge':
            cookies = browser_cookie3.edge(domain_name=domain)
        elif browser_lower == 'safari':
            cookies = browser_cookie3.safari(domain_name=domain)
        
        # Analyze cookies before importing
        domain_matches = 0
        secure_cookies = 0
        session_cookies = 0
        persistent_cookies = 0
        
        for cookie in cookies:
            all_cookies.append({
                "name": cookie.name,
                "domain": cookie.domain,
                "path": cookie.path,
                "secure": getattr(cookie, 'secure', False),
                "expires": getattr(cookie, 'expires', None)
            })
            
            if domain and domain in cookie.domain:
                domain_matches += 1
            
            if getattr(cookie, 'secure', False):
                secure_cookies += 1
                
            if getattr(cookie, 'expires', None) is None:
                session_cookies += 1
            else:
                persistent_cookies += 1
        
        diagnostics.update({
            "total_cookies_in_file": len(all_cookies),
            "domain_matches": domain_matches,
            "secure_cookies": secure_cookies,
            "session_cookies": session_cookies,
            "persistent_cookies": persistent_cookies
        })
        
        # Import cookies into requests session
        cookies_imported = 0
        import_errors = []
        
        for cookie in cookies:
            try:
                session.cookies.set(
                    name=cookie.name,
                    value=cookie.value,
                    domain=cookie.domain,
                    path=cookie.path or '/',
                    secure=getattr(cookie, 'secure', False)
                )
                cookies_imported += 1
            except Exception as import_error:
                import_errors.append(f"Failed to import {cookie.name}: {str(import_error)}")
                if len(import_errors) > 5:  # Limit error collection
                    break
        
        cookies_after_import = len(session.cookies)
        
        # Build comprehensive result
        result = {
            "browser": browser,
            "domain": domain or "all domains",
            "cookies_imported": cookies_imported,
            "cookies_before_import": cookies_before_import,
            "cookies_after_import": cookies_after_import,
            "net_cookies_added": cookies_after_import - cookies_before_import,
            "status": f"Successfully imported {cookies_imported} cookies from {browser}",
            "diagnostics": {
                **diagnostics,
                "import_errors": import_errors,
                "cookie_breakdown": {
                    "total_found": len(all_cookies),
                    "domain_filtered": domain_matches if domain else len(all_cookies),
                    "successfully_imported": cookies_imported,
                    "import_failures": len(import_errors)
                },
                "cookie_types": {
                    "secure_cookies": secure_cookies,
                    "session_cookies": session_cookies, 
                    "persistent_cookies": persistent_cookies
                },
                "sample_cookies": [
                    {
                        "name": cookie["name"],
                        "domain": cookie["domain"],
                        "secure": cookie["secure"]
                    } for cookie in all_cookies[:5]
                ] if verbose and all_cookies else []
            },
            "recommendations": []
        }
        
        # Add specific recommendations based on results
        if cookies_imported == 0:
            if not diagnostics["browser_found"]:
                result["recommendations"].extend([
                    f"{browser} browser data directory not found. Ensure {browser} is installed.",
                    "Check if browser has been used to visit websites before importing cookies.",
                    "Verify browser data directory permissions."
                ])
            elif diagnostics["total_cookies_in_file"] == 0:
                result["recommendations"].extend([
                    f"No cookies found in {browser} browser data.",
                    "Open browser and visit websites to create cookies first.",
                    "Check if browser is running (close it before importing)."
                ])
            elif domain and diagnostics["domain_matches"] == 0:
                result["recommendations"].extend([
                    f"No cookies found for domain '{domain}' in {browser}.",
                    f"Visit {domain} in {browser} browser first to create cookies.",
                    "Check domain spelling or try without domain filter."
                ])
            elif import_errors:
                result["recommendations"].extend([
                    "Cookie import errors detected. Check error details above.",
                    "Some cookies may have invalid format or unsupported attributes.",
                    "Try closing browser completely before importing."
                ])
        elif cookies_imported < diagnostics["total_cookies_in_file"] / 2:
            result["recommendations"].extend([
                "Only partial cookie import succeeded. Check import errors.",
                "Some cookies may be encrypted or session-only.",
                "Try importing with browser completely closed."
            ])
        else:
            result["recommendations"].extend([
                f"Cookie import successful! {cookies_imported} cookies imported from {browser}.",
                "Cookies are now available for authenticated requests.",
                "Use get_session_info to verify imported cookies."
            ])
        
        logger.info(f"Imported {cookies_imported} cookies from {browser}")
        return result
        
    except Exception as e:
        error_type = type(e).__name__
        error_msg = str(e)
        
        # Analyze common error types
        if "permission" in error_msg.lower() or "access" in error_msg.lower():
            diagnostics["access_error"] = "Permission denied - browser data directory not accessible"
            recommendations = [
                "Close browser completely before importing cookies",
                "Check file permissions for browser data directory", 
                "Run script with appropriate user permissions",
                "Try importing from different browser"
            ]
        elif "database" in error_msg.lower() or "sqlite" in error_msg.lower():
            diagnostics["access_error"] = "Database error - browser database may be locked or corrupted"
            recommendations = [
                "Ensure browser is completely closed",
                "Check if browser process is still running",
                "Try restarting browser and importing again",
                "Check browser data integrity"
            ]
        elif "not found" in error_msg.lower() or "file" in error_msg.lower():
            diagnostics["access_error"] = "Browser data files not found"
            recommendations = [
                f"Verify {browser} is installed and has been used",
                "Check browser installation path",
                "Try importing from different browser",
                "Ensure browser has created cookie data"
            ]
        else:
            diagnostics["access_error"] = f"Unknown error: {error_msg}"
            recommendations = [
                "Check browser compatibility with browser-cookie3",
                "Verify browser version is supported",
                "Try different browser or contact support"
            ]
        
        error_result = {
            "browser": browser,
            "domain": domain or "all domains", 
            "cookies_imported": 0,
            "error": error_msg,
            "error_type": error_type,
            "diagnostics": diagnostics,
            "recommendations": recommendations
        }
        
        logger.error(f"Error importing cookies from {browser}: {e}")
        return error_result