use serde::{Deserialize, Serialize};
use base64::Engine;
use std::fs;
use std::process::Command;
use std::os::windows::process::CommandExt;
use std::collections::HashMap;
use std::path::PathBuf;
use tauri::{AppHandle, Manager};
use crate::services::log_service::emit_log;

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct RegistryValue {
    pub v_type: String, // "String", "Dword", "Qword", "MultiString", "ExpandString"
    pub data: serde_json::Value,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(tag = "type")]
pub enum PostInstallStep {
    #[serde(rename = "registry_batch")]
    RegistryBatch {
        root: String,
        base_path: String,
        values: HashMap<String, RegistryValue>,
        delay_ms: Option<u64>,
    },
    #[serde(rename = "file_copy")]
    FileCopy {
        src: String,
        dest: String,
        delay_ms: Option<u64>,
    },
    #[serde(rename = "file_delete")]
    FileDelete {
        path: String,
        delay_ms: Option<u64>,
    },
    #[serde(rename = "command")]
    Command {
        run: String,
        delay_ms: Option<u64>,
    },
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Software {
    pub id: String,
    pub name: String,
    pub description: Option<String>,
    pub category: 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", "configuring", "success", "error"
    #[serde(default = "default_progress")]
    pub progress: f32,
    #[serde(default = "default_false")]
    pub use_manifest: bool,
    pub manifest_url: Option<String>,
    pub post_install: Option<Vec<PostInstallStep>>,
    pub post_install_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
        winget settings --enable LocalManifestFiles
    "#;
    
    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'
        Import-Module Microsoft.WinGet.Client -ErrorAction SilentlyContinue
        
        $pkgs = Get-WinGetPackage -ErrorAction SilentlyContinue | Where-Object { $_.IsUpdateAvailable }
        
        if ($pkgs) {
            $pkgs | ForEach-Object {
                [PSCustomObject]@{ 
                    Name = [string]$_.Name; 
                    Id = [string]$_.Id; 
                    InstalledVersion = [string]$_.InstalledVersion; 
                    AvailableVersions = $_.AvailableVersions;
                    IconUrl = $null
                } 
            } | ConvertTo-Json -Compress
        } else {
            "[]"
        }
    "#;

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

pub fn get_software_info(handle: &AppHandle, id: &str) -> Option<Software> {
    let log_id = format!("get-info-{}", chrono::Local::now().timestamp_millis());
    let script = format!(r#"
        $OutputEncoding = [Console]::OutputEncoding = [System.Text.Encoding]::UTF8
        $ErrorActionPreference = 'SilentlyContinue'
        Import-Module Microsoft.WinGet.Client -ErrorAction SilentlyContinue
        $pkg = Get-WinGetPackage -Id "{}" -ErrorAction SilentlyContinue
        if ($pkg) {{
            [PSCustomObject]@{{ 
                Name = [string]$pkg.Name; 
                Id = [string]$pkg.Id; 
                InstalledVersion = [string]$pkg.InstalledVersion; 
                AvailableVersions = @() 
            }} | ConvertTo-Json -Compress
        }}
    "#, id);

    let res = execute_powershell(handle, &log_id, "Fetch Single Software Info", &script);
    res.into_iter().next()
}

pub fn get_cached_or_extract_icon(handle: &AppHandle, id: &str, name: &str) -> Option<String> {
    let cache_key = sanitize_cache_key(id);
    let icon_dir = get_icon_cache_dir(handle);
    let icon_path = icon_dir.join(format!("{}.png", cache_key));

    if let Ok(bytes) = fs::read(&icon_path) {
        return Some(format!(
            "data:image/png;base64,{}",
            base64::engine::general_purpose::STANDARD.encode(bytes)
        ));
    }

    let log_id = format!("icon-{}", cache_key);
    emit_log(handle, &log_id, "Icon Lookup", &format!("Resolving icon for {}...", id), "info");

    let script = format!(r#"
        $OutputEncoding = [Console]::OutputEncoding = [System.Text.Encoding]::UTF8
        $ErrorActionPreference = 'SilentlyContinue'
        Add-Type -AssemblyName System.Drawing
        Import-Module Microsoft.WinGet.Client -ErrorAction SilentlyContinue

        $packageId = @'
{id}
'@
        $packageName = @'
{name}
'@

        $foundPath = ""
        $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
        $matchedLnk = $lnkFiles | Where-Object {{ $_.BaseName -eq $packageName -or $packageName -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 {{
                    $foundPath = $matchedLnk.FullName
                }}
            }} catch {{
                $foundPath = $matchedLnk.FullName
            }}
        }}

        if (-not $foundPath) {{
            $registryPaths = @(
                "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*",
                "HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*",
                "HKCU:\Software\Microsoft\Windows\CurrentVersion\Uninstall\*"
            )
            $regItems = Get-ItemProperty $registryPaths
            $matchedReg = $regItems | Where-Object {{ $_.DisplayName -eq $packageName -or $_.PSChildName -eq $packageId }} | 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 }}
                }}
            }}
        }}

        if ($foundPath -and (Test-Path $foundPath)) {{
            try {{
                $icon = [System.Drawing.Icon]::ExtractAssociatedIcon($foundPath)
                if ($icon) {{
                    $bitmap = $icon.ToBitmap()
                    $ms = New-Object System.IO.MemoryStream
                    $bitmap.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png)
                    [Convert]::ToBase64String($ms.ToArray())
                    $ms.Dispose()
                    $bitmap.Dispose()
                    $icon.Dispose()
                }}
            }} catch {{}}
        }}
    "#, id = id, name = name);

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

    let stdout = String::from_utf8_lossy(&output.stdout);
    let encoded = stdout.trim_start_matches('\u{feff}').trim();
    if encoded.is_empty() {
        return None;
    }

    let bytes = base64::engine::general_purpose::STANDARD.decode(encoded).ok()?;
    if fs::create_dir_all(&icon_dir).is_err() {
        return Some(format!("data:image/png;base64,{}", encoded));
    }
    let _ = fs::write(&icon_path, &bytes);
    Some(format!("data:image/png;base64,{}", encoded))
}

fn execute_powershell(handle: &AppHandle, log_id: &str, cmd_title: &str, script: &str) -> Vec<Software> {
    emit_log(handle, log_id, cmd_title, "Fetching data from Winget...", "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 get_icon_cache_dir(handle: &AppHandle) -> PathBuf {
    let app_data_dir = handle.path().app_data_dir().unwrap_or_default();
    app_data_dir.join("icons")
}

fn sanitize_cache_key(id: &str) -> String {
    id.chars()
        .map(|c| if c.is_ascii_alphanumeric() { c } else { '_' })
        .collect()
}

fn map_package(p: WingetPackage) -> Software {
    Software {
        id: p.id,
        name: p.name,
        description: None,
        category: 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,
        post_install: None,
        post_install_url: None,
    }
}