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>,
    pub status: String, // "idle", "pending", "installing", "success", "error"
    pub progress: f32,
}

#[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 fn ensure_winget_dependencies(handle: &AppHandle) -> Result<(), String> {
    let log_id = "env-check";
    emit_log(handle, log_id, "Environment Check", "Starting system configuration...", "info");

    let setup_script = r#"
        $ErrorActionPreference = 'SilentlyContinue'
        Write-Output "Checking module status..."
        if (Get-Module -ListAvailable Microsoft.WinGet.Client) {
            Write-Output "ALREADY_READY"
            exit 0
        }
        Write-Output "Step 1: Enabling TLS 1.2"
        [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
    "#;
    
    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();
            emit_log(handle, log_id, "", &stdout, "info");
            
            if stdout.contains("ALREADY_READY") {
                emit_log(handle, log_id, "Result", "Ready (Fast check).", "success");
                Ok(())
            } else {
                let check = Command::new("powershell")
                    .args(["-NoProfile", "-Command", "Get-Module -ListAvailable Microsoft.WinGet.Client"])
                    .creation_flags(0x08000000)
                    .output();
                
                if check.map(|o| !o.stdout.is_empty()).unwrap_or(false) {
                    emit_log(handle, log_id, "Result", "Module installed successfully.", "success");
                    Ok(())
                } else {
                    emit_log(handle, log_id, "Result", "Module installation failed.", "error");
                    Err("Setup failed".to_string())
                }
            }
        },
        Err(e) => {
            emit_log(handle, log_id, "Fatal Error", &e.to_string(), "error");
            Err(e.to_string())
        }
    }
}

pub fn list_all_software(handle: &AppHandle) -> Vec<Software> {
    let log_id = format!("list-all-{}", 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 All 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 
                } 
            } | 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 software found.", "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: None,
        status: "idle".to_string(),
        progress: 0.0,
    }
}