mod cmd;
pub mod config;
mod core;
mod enhance;
mod feat;
mod ipc;
mod module;
mod process;
mod state;
mod utils;
#[cfg(target_os = "macos")]
use crate::utils::window_manager::WindowManager;
use crate::{
    core::hotkey,
    process::AsyncHandler,
    utils::{resolve, resolve::resolve_scheme, server},
};
use config::Config;
use parking_lot::Mutex;
use tauri::AppHandle;
#[cfg(target_os = "macos")]
use tauri::Manager;
#[cfg(target_os = "macos")]
use tauri_plugin_autostart::MacosLauncher;
use tauri_plugin_deep_link::DeepLinkExt;
use tokio::time::{timeout, Duration};
use utils::logging::Type;

/// A global singleton handle to the application.
pub struct AppHandleManager {
    handle: Mutex<Option<AppHandle>>,
}

impl AppHandleManager {
    /// Create a new AppHandleManager instance
    fn new() -> Self {
        Self {
            handle: Mutex::new(None),
        }
    }

    /// Initialize the app handle manager with an app handle.
    pub fn init(&self, handle: AppHandle) {
        let mut app_handle = self.handle.lock();
        if app_handle.is_none() {
            *app_handle = Some(handle);
            logging!(
                info,
                Type::Setup,
                true,
                "AppHandleManager initialized with handle"
            );
        }
    }

    /// Get the app handle if it has been initialized.
    pub fn get(&self) -> Option<AppHandle> {
        self.handle.lock().clone()
    }

    /// Get the app handle, panics if it hasn't been initialized.
    pub fn get_handle(&self) -> AppHandle {
        self.get().expect("AppHandle not initialized")
    }

    /// Check if the app handle has been initialized.
    pub fn is_initialized(&self) -> bool {
        self.handle.lock().is_some()
    }

    #[cfg(target_os = "macos")]
    pub fn set_activation_policy(&self, policy: tauri::ActivationPolicy) -> Result<(), String> {
        let app_handle = self.handle.lock();
        if let Some(app_handle) = app_handle.as_ref() {
            app_handle
                .set_activation_policy(policy)
                .map_err(|e| e.to_string())
        } else {
            Err("AppHandle not initialized".to_string())
        }
    }

    pub fn set_activation_policy_regular(&self) {
        #[cfg(target_os = "macos")]
        {
            if let Err(e) = self.set_activation_policy(tauri::ActivationPolicy::Regular) {
                logging!(
                    warn,
                    Type::Setup,
                    true,
                    "Failed to set regular activation policy: {}",
                    e
                );
            }
        }
    }

    pub fn set_activation_policy_accessory(&self) {
        #[cfg(target_os = "macos")]
        {
            if let Err(e) = self.set_activation_policy(tauri::ActivationPolicy::Accessory) {
                logging!(
                    warn,
                    Type::Setup,
                    true,
                    "Failed to set accessory activation policy: {}",
                    e
                );
            }
        }
    }

    pub fn set_activation_policy_prohibited(&self) {
        #[cfg(target_os = "macos")]
        {
            if let Err(e) = self.set_activation_policy(tauri::ActivationPolicy::Prohibited) {
                logging!(
                    warn,
                    Type::Setup,
                    true,
                    "Failed to set prohibited activation policy: {}",
                    e
                );
            }
        }
    }
}

// Use unified singleton macro
singleton_with_logging!(AppHandleManager, INSTANCE, "AppHandleManager");

/// Application initialization helper functions
mod app_init {
    use super::*;

    /// Initialize singleton monitoring for other instances
    pub fn init_singleton_check() {
        AsyncHandler::spawn(move || async move {
            logging!(info, Type::Setup, true, "开始检查单例实例...");
            match timeout(Duration::from_secs(3), server::check_singleton()).await {
                Ok(result) => {
                    if result.is_err() {
                        logging!(info, Type::Setup, true, "检测到已有应用实例运行");
                        if let Some(app_handle) = AppHandleManager::global().get() {
                            app_handle.exit(0);
                        } else {
                            std::process::exit(0);
                        }
                    } else {
                        logging!(info, Type::Setup, true, "未检测到其他应用实例");
                    }
                }
                Err(_) => {
                    logging!(
                        warn,
                        Type::Setup,
                        true,
                        "单例检查超时，假定没有其他实例运行"
                    );
                }
            }
        });
    }

    /// Setup plugins for the Tauri builder
    pub fn setup_plugins(builder: tauri::Builder<tauri::Wry>) -> tauri::Builder<tauri::Wry> {
        #[allow(unused_mut)]
        let mut builder = builder
            .plugin(tauri_plugin_notification::init())
            .plugin(tauri_plugin_updater::Builder::new().build())
            .plugin(tauri_plugin_clipboard_manager::init())
            .plugin(tauri_plugin_process::init())
            .plugin(tauri_plugin_global_shortcut::Builder::new().build())
            .plugin(tauri_plugin_fs::init())
            .plugin(tauri_plugin_dialog::init())
            .plugin(tauri_plugin_shell::init())
            .plugin(tauri_plugin_deep_link::init());

        #[cfg(debug_assertions)]
        {
            builder = builder.plugin(tauri_plugin_devtools::init());
        }

        builder.manage(std::sync::Mutex::new(
            state::lightweight::LightWeightState::default(),
        ))
    }

    /// Setup deep link handling
    pub fn setup_deep_links(app: &tauri::App) -> Result<(), Box<dyn std::error::Error>> {
        #[cfg(any(target_os = "linux", all(debug_assertions, windows)))]
        {
            logging!(info, Type::Setup, true, "注册深层链接...");
            app.deep_link().register_all()?;
        }

        app.deep_link().on_open_url(|event| {
            AsyncHandler::spawn(move || {
                let url = event.urls().first().map(|u| u.to_string());
                async move {
                    if let Some(url) = url {
                        if let Err(e) = resolve_scheme(url).await {
                            logging!(error, Type::Setup, true, "Failed to resolve scheme: {}", e);
                        }
                    }
                }
            });
        });

        Ok(())
    }

    /// Setup autostart plugin
    pub fn setup_autostart(app: &tauri::App) -> Result<(), Box<dyn std::error::Error>> {
        #[cfg(target_os = "macos")]
        let mut auto_start_plugin_builder = tauri_plugin_autostart::Builder::new();
        #[cfg(not(target_os = "macos"))]
        let auto_start_plugin_builder = tauri_plugin_autostart::Builder::new();

        #[cfg(target_os = "macos")]
        {
            auto_start_plugin_builder = auto_start_plugin_builder
                .macos_launcher(MacosLauncher::LaunchAgent)
                .app_name(app.config().identifier.clone());
        }
        app.handle().plugin(auto_start_plugin_builder.build())?;
        Ok(())
    }

    /// Setup window state management
    pub fn setup_window_state(app: &tauri::App) -> Result<(), Box<dyn std::error::Error>> {
        logging!(info, Type::Setup, true, "初始化窗口状态管理...");
        let window_state_plugin = tauri_plugin_window_state::Builder::new()
            .with_filename("window_state.json")
            .with_state_flags(tauri_plugin_window_state::StateFlags::default())
            .build();
        app.handle().plugin(window_state_plugin)?;
        Ok(())
    }

    /// Initialize core components asynchronously
    pub fn init_core_async(app_handle: tauri::AppHandle) {
        AsyncHandler::spawn(move || async move {
            logging!(info, Type::Setup, true, "异步执行应用设置...");
            match timeout(
                Duration::from_secs(30),
                resolve::resolve_setup_async(&app_handle),
            )
            .await
            {
                Ok(_) => {
                    logging!(info, Type::Setup, true, "应用设置成功完成");
                }
                Err(_) => {
                    logging!(
                        error,
                        Type::Setup,
                        true,
                        "应用设置超时(30秒)，继续执行后续流程"
                    );
                }
            }
        });
    }

    /// Initialize core components synchronously
    pub fn init_core_sync(app_handle: &tauri::AppHandle) -> Result<(), Box<dyn std::error::Error>> {
        logging!(info, Type::Setup, true, "初始化AppHandleManager...");
        AppHandleManager::global().init(app_handle.clone());

        logging!(info, Type::Setup, true, "初始化核心句柄...");
        core::handle::Handle::global().init(app_handle);

        logging!(info, Type::Setup, true, "初始化配置...");
        utils::init::init_config()?;

        logging!(info, Type::Setup, true, "初始化资源...");
        utils::init::init_resources()?;

        logging!(info, Type::Setup, true, "核心组件初始化完成");
        Ok(())
    }

    /// Generate all command handlers for the application
    pub fn generate_handlers(
    ) -> impl Fn(tauri::ipc::Invoke<tauri::Wry>) -> bool + Send + Sync + 'static {
        tauri::generate_handler![
            // Common commands
            cmd::get_sys_proxy,
            cmd::get_auto_proxy,
            cmd::open_app_dir,
            cmd::open_logs_dir,
            cmd::open_web_url,
            cmd::open_core_dir,
            cmd::get_portable_flag,
            cmd::get_network_interfaces,
            cmd::get_system_hostname,
            cmd::restart_app,
            // Core management
            cmd::start_core,
            cmd::stop_core,
            cmd::restart_core,
            // Application lifecycle
            cmd::notify_ui_ready,
            cmd::update_ui_stage,
            cmd::reset_ui_ready_state,
            cmd::get_running_mode,
            cmd::get_app_uptime,
            cmd::get_auto_launch_status,
            cmd::is_admin,
            // Lightweight mode
            cmd::entry_lightweight_mode,
            cmd::exit_lightweight_mode,
            // Service management
            cmd::install_service,
            cmd::uninstall_service,
            cmd::reinstall_service,
            cmd::repair_service,
            cmd::is_service_available,
            // Clash core commands
            cmd::get_clash_info,
            cmd::patch_clash_config,
            cmd::patch_clash_mode,
            cmd::change_clash_core,
            cmd::get_runtime_config,
            cmd::get_runtime_yaml,
            cmd::get_runtime_exists,
            cmd::get_runtime_logs,
            cmd::invoke_uwp_tool,
            cmd::copy_clash_env,
            cmd::get_proxies,
            cmd::force_refresh_proxies,
            cmd::get_providers_proxies,
            cmd::save_dns_config,
            cmd::apply_dns_config,
            cmd::check_dns_config_exists,
            cmd::get_dns_config_content,
            cmd::validate_dns_config,
            cmd::get_clash_version,
            cmd::get_clash_config,
            cmd::force_refresh_clash_config,
            cmd::update_geo_data,
            cmd::upgrade_clash_core,
            cmd::get_clash_rules,
            cmd::update_proxy_choice,
            cmd::get_proxy_providers,
            cmd::get_rule_providers,
            cmd::proxy_provider_health_check,
            cmd::update_proxy_provider,
            cmd::update_rule_provider,
            cmd::get_clash_connections,
            cmd::delete_clash_connection,
            cmd::close_all_clash_connections,
            cmd::get_group_proxy_delays,
            cmd::is_clash_debug_enabled,
            cmd::clash_gc,
            // Logging and monitoring
            cmd::get_clash_logs,
            cmd::start_logs_monitoring,
            cmd::stop_logs_monitoring,
            cmd::clear_logs,
            cmd::get_traffic_data,
            cmd::get_memory_data,
            cmd::get_formatted_traffic_data,
            cmd::get_formatted_memory_data,
            cmd::get_system_monitor_overview,
            cmd::start_traffic_service,
            cmd::stop_traffic_service,
            // Verge configuration
            cmd::get_verge_config,
            cmd::patch_verge_config,
            cmd::test_delay,
            cmd::get_app_dir,
            cmd::copy_icon_file,
            cmd::download_icon_cache,
            cmd::open_devtools,
            cmd::exit_app,
            cmd::get_network_interfaces_info,
            // Profile management
            cmd::get_profiles,
            cmd::enhance_profiles,
            cmd::patch_profiles_config,
            cmd::view_profile,
            cmd::patch_profile,
            cmd::create_profile,
            cmd::import_profile,
            cmd::reorder_profile,
            cmd::update_profile,
            cmd::delete_profile,
            cmd::read_profile_file,
            cmd::save_profile_file,
            cmd::get_next_update_time,
            // Script validation
            cmd::script_validate_notice,
            cmd::validate_script_file,
            // Clash API
            cmd::clash_api_get_proxy_delay,
            // Backup and WebDAV
            cmd::create_webdav_backup,
            cmd::save_webdav_config,
            cmd::list_webdav_backup,
            cmd::delete_webdav_backup,
            cmd::restore_webdav_backup,
            // Diagnostics and system info
            cmd::export_diagnostic_info,
            cmd::get_system_info,
            // Media unlock checker
            cmd::get_unlock_items,
            cmd::check_media_unlock,
        ]
    }
}

pub fn run() {
    // Setup singleton check
    app_init::init_singleton_check();

    // Initialize network manager
    utils::network::NetworkManager::global().init();

    // Initialize portable flag
    let _ = utils::dirs::init_portable_flag();

    // Set Linux environment variable
    #[cfg(target_os = "linux")]
    {
        std::env::set_var("WEBKIT_DISABLE_DMABUF_RENDERER", "1");

        let desktop_env = std::env::var("XDG_CURRENT_DESKTOP")
            .unwrap_or_default()
            .to_uppercase();
        let is_kde_desktop = desktop_env.contains("KDE");
        let is_plasma_desktop = desktop_env.contains("PLASMA");

        if is_kde_desktop || is_plasma_desktop {
            std::env::set_var("GTK_CSD", "0");
            logging!(
                info,
                Type::Setup,
                true,
                "KDE detected: Disabled GTK CSD for better titlebar stability."
            );
        }
    }

    // Create and configure the Tauri builder
    let builder = app_init::setup_plugins(tauri::Builder::default())
        .setup(|app| {
            logging!(info, Type::Setup, true, "开始应用初始化...");

            // Setup autostart plugin
            if let Err(e) = app_init::setup_autostart(app) {
                logging!(error, Type::Setup, true, "Failed to setup autostart: {}", e);
            }

            // Setup deep links
            if let Err(e) = app_init::setup_deep_links(app) {
                logging!(
                    error,
                    Type::Setup,
                    true,
                    "Failed to setup deep links: {}",
                    e
                );
            }

            // Setup window state management
            if let Err(e) = app_init::setup_window_state(app) {
                logging!(
                    error,
                    Type::Setup,
                    true,
                    "Failed to setup window state: {}",
                    e
                );
            }

            // Initialize core components asynchronously
            app_init::init_core_async(app.handle().clone());

            logging!(info, Type::Setup, true, "执行主要设置操作...");

            // Initialize core components synchronously
            if let Err(e) = app_init::init_core_sync(app.handle()) {
                logging!(
                    error,
                    Type::Setup,
                    true,
                    "Failed to initialize core components: {}",
                    e
                );
                return Err(e);
            }

            logging!(info, Type::Setup, true, "初始化完成，继续执行");
            Ok(())
        })
        .invoke_handler(app_init::generate_handlers());

    /// Event handling helper functions
    mod event_handlers {
        use super::*;

        /// Handle application ready/resumed events
        pub fn handle_ready_resumed(app_handle: &tauri::AppHandle) {
            logging!(info, Type::System, true, "应用就绪或恢复");
            AppHandleManager::global().init(app_handle.clone());

            #[cfg(target_os = "macos")]
            {
                if let Some(window) = app_handle.get_webview_window("main") {
                    logging!(info, Type::Window, true, "设置macOS窗口标题");
                    let _ = window.set_title("Clash Verge");
                }
            }
        }

        /// Handle application reopen events (macOS)
        #[cfg(target_os = "macos")]
        pub fn handle_reopen(app_handle: &tauri::AppHandle, has_visible_windows: bool) {
            logging!(
                info,
                Type::System,
                true,
                "处理 macOS 应用重新打开事件: has_visible_windows={}",
                has_visible_windows
            );

            AppHandleManager::global().init(app_handle.clone());

            if !has_visible_windows {
                // 当没有可见窗口时，设置为 regular 模式并显示主窗口
                AppHandleManager::global().set_activation_policy_regular();

                logging!(info, Type::System, true, "没有可见窗口，尝试显示主窗口");

                let result = WindowManager::show_main_window();
                logging!(
                    info,
                    Type::System,
                    true,
                    "窗口显示操作完成，结果: {:?}",
                    result
                );
            } else {
                logging!(info, Type::System, true, "已有可见窗口，无需额外操作");
            }
        }

        /// Handle window close requests
        pub fn handle_window_close(api: &tauri::WindowEvent) {
            #[cfg(target_os = "macos")]
            AppHandleManager::global().set_activation_policy_accessory();

            if core::handle::Handle::global().is_exiting() {
                return;
            }

            log::info!(target: "app", "closing window...");
            if let tauri::WindowEvent::CloseRequested { api, .. } = api {
                api.prevent_close();
                if let Some(window) = core::handle::Handle::global().get_window() {
                    let _ = window.hide();
                } else {
                    logging!(warn, Type::Window, true, "尝试隐藏窗口但窗口不存在");
                }
            }
        }

        /// Handle window focus events
        pub fn handle_window_focus(focused: bool) {
            let is_enable_global_hotkey = Config::verge()
                .latest_ref()
                .enable_global_hotkey
                .unwrap_or(true);

            if focused {
                #[cfg(target_os = "macos")]
                {
                    use crate::core::hotkey::SystemHotkey;
                    if let Err(e) =
                        hotkey::Hotkey::global().register_system_hotkey(SystemHotkey::CmdQ)
                    {
                        logging!(error, Type::Hotkey, true, "Failed to register CMD+Q: {}", e);
                    }
                    if let Err(e) =
                        hotkey::Hotkey::global().register_system_hotkey(SystemHotkey::CmdW)
                    {
                        logging!(error, Type::Hotkey, true, "Failed to register CMD+W: {}", e);
                    }
                }

                if !is_enable_global_hotkey {
                    if let Err(e) = hotkey::Hotkey::global().init() {
                        logging!(error, Type::Hotkey, true, "Failed to init hotkeys: {}", e);
                    }
                }
                return;
            }

            // Handle unfocused state
            #[cfg(target_os = "macos")]
            {
                use crate::core::hotkey::SystemHotkey;
                if let Err(e) =
                    hotkey::Hotkey::global().unregister_system_hotkey(SystemHotkey::CmdQ)
                {
                    logging!(
                        error,
                        Type::Hotkey,
                        true,
                        "Failed to unregister CMD+Q: {}",
                        e
                    );
                }
                if let Err(e) =
                    hotkey::Hotkey::global().unregister_system_hotkey(SystemHotkey::CmdW)
                {
                    logging!(
                        error,
                        Type::Hotkey,
                        true,
                        "Failed to unregister CMD+W: {}",
                        e
                    );
                }
            }

            if !is_enable_global_hotkey {
                if let Err(e) = hotkey::Hotkey::global().reset() {
                    logging!(error, Type::Hotkey, true, "Failed to reset hotkeys: {}", e);
                }
            }
        }

        /// Handle window destroyed events
        pub fn handle_window_destroyed() {
            #[cfg(target_os = "macos")]
            {
                use crate::core::hotkey::SystemHotkey;
                if let Err(e) =
                    hotkey::Hotkey::global().unregister_system_hotkey(SystemHotkey::CmdQ)
                {
                    logging!(
                        error,
                        Type::Hotkey,
                        true,
                        "Failed to unregister CMD+Q on destroy: {}",
                        e
                    );
                }
                if let Err(e) =
                    hotkey::Hotkey::global().unregister_system_hotkey(SystemHotkey::CmdW)
                {
                    logging!(
                        error,
                        Type::Hotkey,
                        true,
                        "Failed to unregister CMD+W on destroy: {}",
                        e
                    );
                }
            }
        }
    }

    // Build the application
    let app = builder
        .build(tauri::generate_context!())
        .expect("error while running tauri application");

    app.run(|app_handle, e| match e {
        tauri::RunEvent::Ready | tauri::RunEvent::Resumed => {
            event_handlers::handle_ready_resumed(app_handle);
        }
        #[cfg(target_os = "macos")]
        tauri::RunEvent::Reopen {
            has_visible_windows,
            ..
        } => {
            event_handlers::handle_reopen(app_handle, has_visible_windows);
        }
        tauri::RunEvent::ExitRequested { api, code, .. } => {
            if code.is_none() {
                api.prevent_exit();
            }
        }
        tauri::RunEvent::Exit => {
            // Avoid duplicate cleanup
            if core::handle::Handle::global().is_exiting() {
                return;
            }
            feat::clean();
        }
        tauri::RunEvent::WindowEvent { label, event, .. } => {
            if label == "main" {
                match event {
                    tauri::WindowEvent::CloseRequested { .. } => {
                        event_handlers::handle_window_close(&event);
                    }
                    tauri::WindowEvent::Focused(focused) => {
                        event_handlers::handle_window_focus(focused);
                    }
                    tauri::WindowEvent::Destroyed => {
                        event_handlers::handle_window_destroyed();
                    }
                    _ => {}
                }
            }
        }
        _ => {}
    });
}