use serde::{Deserialize, Serialize};
use std::process::Command;
use std::os::windows::process::CommandExt;
use tauri::AppHandle;
use crate::emit_log;

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Software {
    pub id: String,
    pub name: String,
    pub description: Option<String>,
    pub version: Option<String>,
    pub available_version: Option<String>,
    pub icon_url: Option<String>,
    #[serde(default = "default_status")]
    pub status: String, // "idle", "pending", "installing", "success", "error"
    #[serde(default = "default_progress")]
    pub progress: f32,
    #[serde(default = "default_false")]
    pub use_manifest: bool,
    pub manifest_url: Option<String>,
}

fn default_status() -> String { "idle".to_string() }
fn default_progress() -> f32 { 0.0 }
fn default_false() -> bool { false }

#[derive(Debug, Deserialize)]
#[serde(rename_all = "PascalCase")]
struct WingetPackage {
    pub id: String,
    pub name: String,
    pub installed_version: Option<String>,
    pub available_versions: Option<Vec<String>>,
    pub icon_url: Option<String>,
}

pub fn ensure_winget_dependencies(handle: &AppHandle) -> Result<(), String> {
    emit_log(handle, "env-check", "Environment Check", "Checking system components...", "info");

    // 优化后的极速检测脚本
    let setup_script = r#"
        # 强制指定输出编码为 UTF8 (无 BOM)
        $OutputEncoding = [Console]::OutputEncoding = [System.Text.Encoding]::UTF8
        $ErrorActionPreference = 'SilentlyContinue'
        
        # 使用多种方式确认环境是否已就绪
        $module = Get-Module -ListAvailable Microsoft.WinGet.Client
        $command = Get-Command Get-WinGetPackage -ErrorAction SilentlyContinue

        if ($module -or $command) {
            Write-Output "CHECK_RESULT:READY"
            exit 0
        }

        # 仅在确实缺失时才输出配置日志并开始安装
        Write-Output "CHECK_RESULT:NEED_INSTALL"
        
        [Net.ServicePointManager]::SecurityProtocol = [Net.ServicePointManager]::SecurityProtocol -bor [Net.SecurityProtocolType]::Tls12
        Import-Module PackageManagement -ErrorAction SilentlyContinue
        
        if ($null -eq (Get-PackageProvider -Name NuGet -ErrorAction SilentlyContinue)) {
            Install-PackageProvider -Name NuGet -MinimumVersion 2.8.5.201 -Force -Confirm:$false
        }
        
        Set-PSRepository -Name 'PSGallery' -InstallationPolicy Trusted
        Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser -Force
        
        Install-Module -Name Microsoft.WinGet.Client -Force -AllowClobber -Scope CurrentUser -Confirm:$false
        winget source update --accept-source-agreements
    "#;
    
    let output = Command::new("powershell")
        .args(["-NoProfile", "-Command", setup_script])
        .creation_flags(0x08000000)
        .output();

    match output {
        Ok(out) => {
            let stdout = String::from_utf8_lossy(&out.stdout).to_string();
            let stderr = String::from_utf8_lossy(&out.stderr).to_string();
            
            // 清理输出字符串，移除 BOM 和换行
            let clean_stdout = stdout.trim_start_matches('\u{feff}').trim();
            
            if clean_stdout.contains("CHECK_RESULT:READY") {
                emit_log(handle, "env-check", "Result", "Environment is already configured. Skipping install.", "success");
                Ok(())
            } else {
                // 如果执行了安装路径，检查最终结果
                let check_final = Command::new("powershell")
                    .args(["-NoProfile", "-Command", "Get-Module -ListAvailable Microsoft.WinGet.Client"])
                    .creation_flags(0x08000000)
                    .output();
                
                if check_final.map(|o| !o.stdout.is_empty()).unwrap_or(false) {
                    emit_log(handle, "env-check", "Result", "Environment configured successfully.", "success");
                    Ok(())
                } else {
                    emit_log(handle, "env-check", "Error", &format!("OUT: {}\nERR: {}", clean_stdout, stderr), "error");
                    Err("Setup verification failed".to_string())
                }
            }
        },
        Err(e) => {
            emit_log(handle, "env-check", "Fatal Error", &e.to_string(), "error");
            Err(e.to_string())
        }
    }
}

pub fn list_installed_software(handle: &AppHandle) -> Vec<Software> {
    let log_id = format!("list-installed-{}", chrono::Local::now().timestamp_millis());
    let script = r#"
        $OutputEncoding = [Console]::OutputEncoding = [System.Text.Encoding]::UTF8
        $ErrorActionPreference = 'SilentlyContinue'
        Import-Module Microsoft.WinGet.Client -ErrorAction SilentlyContinue
        $pkgs = Get-WinGetPackage -ErrorAction SilentlyContinue
        if ($pkgs) {
            $pkgs | ForEach-Object { 
                [PSCustomObject]@{ 
                    Name = [string]$_.Name; 
                    Id = [string]$_.Id; 
                    InstalledVersion = [string]$_.InstalledVersion; 
                    AvailableVersions = @() 
                } 
            } | ConvertTo-Json -Compress
        } else {
            "[]"
        }
    "#;

    execute_powershell(handle, &log_id, "Fetch Installed Software", script)
}

pub fn list_updates(handle: &AppHandle) -> Vec<Software> {
    let log_id = format!("list-updates-{}", chrono::Local::now().timestamp_millis());
    let script = r#"
        $OutputEncoding = [Console]::OutputEncoding = [System.Text.Encoding]::UTF8
        $ErrorActionPreference = 'SilentlyContinue'
        Add-Type -AssemblyName System.Drawing
        Import-Module Microsoft.WinGet.Client -ErrorAction SilentlyContinue
        
        $pkgs = Get-WinGetPackage -ErrorAction SilentlyContinue | Where-Object { $_.IsUpdateAvailable }
        
        if ($pkgs) {
            $wshShell = New-Object -ComObject WScript.Shell
            
            # 预加载开始菜单快捷方式
            $startMenuPaths = @(
                "$env:ProgramData\Microsoft\Windows\Start Menu\Programs",
                "$env:AppData\Microsoft\Windows\Start Menu\Programs"
            )
            $lnkFiles = Get-ChildItem -Path $startMenuPaths -Filter "*.lnk" -Recurse -File

            # 预加载注册表项
            $registryPaths = @(
                "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*",
                "HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*",
                "HKCU:\Software\Microsoft\Windows\CurrentVersion\Uninstall\*"
            )
            $regItems = Get-ItemProperty $registryPaths

            $pkgs | ForEach-Object {
                $p = $_
                $iconUrl = $null
                $foundPath = ""

                # 策略 1: 寻找并解析开始菜单快捷方式 (去除箭头关键点)
                $matchedLnk = $lnkFiles | Where-Object { $_.BaseName -eq $p.Name -or $p.Name -like "*$($_.BaseName)*" } | Select-Object -First 1
                if ($matchedLnk) {
                    try {
                        # 解析快捷方式指向的真实目标
                        $target = $wshShell.CreateShortcut($matchedLnk.FullName).TargetPath
                        if ($target -and (Test-Path $target) -and $target.EndsWith(".exe")) {
                            $foundPath = $target
                        } else {
                            # 如果目标不可读或是 UWP 快捷方式，仍使用快捷方式文件提取
                            $foundPath = $matchedLnk.FullName
                        }
                    } catch {
                        $foundPath = $matchedLnk.FullName
                    }
                }

                # 策略 2: 注册表 DisplayIcon
                if (-not $foundPath) {
                    $matchedReg = $regItems | Where-Object { $_.DisplayName -eq $p.Name -or $_.PSChildName -eq $p.Id } | Select-Object -First 1
                    if ($matchedReg.DisplayIcon) {
                        $foundPath = $matchedReg.DisplayIcon.Split(',')[0].Trim('"')
                    } elseif ($matchedReg.InstallLocation) {
                        $loc = $matchedReg.InstallLocation.Trim('"')
                        if (Test-Path $loc) {
                            $exe = Get-ChildItem -Path $loc -Filter "*.exe" -File | Select-Object -First 1
                            if ($exe) { $foundPath = $exe.FullName }
                        }
                    }
                }

                # 提取并转 Base64
                if ($foundPath -and (Test-Path $foundPath)) {
                    try {
                        $icon = [System.Drawing.Icon]::ExtractAssociatedIcon($foundPath)
                        $bitmap = $icon.ToBitmap()
                        $ms = New-Object System.IO.MemoryStream
                        $bitmap.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png)
                        $base64 = [Convert]::ToBase64String($ms.ToArray())
                        $iconUrl = "data:image/png;base64,$base64"
                        $ms.Dispose(); $bitmap.Dispose(); $icon.Dispose()
                    } catch {}
                }

                [PSCustomObject]@{ 
                    Name = [string]$p.Name; 
                    Id = [string]$p.Id; 
                    InstalledVersion = [string]$p.InstalledVersion; 
                    AvailableVersions = $p.AvailableVersions;
                    IconUrl = $iconUrl
                } 
            } | ConvertTo-Json -Compress
        } else {
            "[]"
        }
    "#;

    execute_powershell(handle, &log_id, "Fetch Updates", script)
}

fn execute_powershell(handle: &AppHandle, log_id: &str, cmd_title: &str, script: &str) -> Vec<Software> {
    emit_log(handle, log_id, cmd_title, "Executing PowerShell...", "info");

    let output = Command::new("powershell")
        .args(["-NoProfile", "-Command", script])
        .creation_flags(0x08000000)
        .output();

    match output {
        Ok(out) => {
            let stdout = String::from_utf8_lossy(&out.stdout);
            let stderr = String::from_utf8_lossy(&out.stderr);
            let clean_json = stdout.trim_start_matches('\u{feff}').trim();
            
            if !out.status.success() && !stderr.is_empty() {
                emit_log(handle, log_id, "", &format!("STDERR: {}", stderr), "error");
            }

            if clean_json.is_empty() || clean_json == "[]" {
                emit_log(handle, log_id, "Result", "No data returned.", "info");
                return vec![];
            }

            let result = parse_json_output(clean_json.to_string());
            emit_log(handle, log_id, "Result", &format!("Successfully parsed {} items.", result.len()), "success");
            result
        },
        Err(e) => {
            emit_log(handle, log_id, "Execution Error", &e.to_string(), "error");
            vec![]
        },
    }
}

fn parse_json_output(json_str: String) -> Vec<Software> {
    if let Ok(packages) = serde_json::from_str::<Vec<WingetPackage>>(&json_str) {
        return packages.into_iter().map(map_package).collect();
    }
    if let Ok(package) = serde_json::from_str::<WingetPackage>(&json_str) {
        return vec![map_package(package)];
    }
    vec![]
}

fn map_package(p: WingetPackage) -> Software {
    Software {
        id: p.id,
        name: p.name,
        description: None,
        version: p.installed_version,
        available_version: p.available_versions.and_then(|v| v.first().cloned()),
        icon_url: p.icon_url,
        status: "idle".to_string(),
        progress: 0.0,
        use_manifest: false,
        manifest_url: None,
    }
}