use super::{AXApplication, AXElement};
use anyhow::{Context, Result};
use std::collections::HashMap;

#[cfg(target_os = "macos")]
use accessibility::{
    AXUIElement, AXUIElementAttributes, ElementFinder, TreeVisitor, TreeWalker, TreeWalkerFlow,
};

#[cfg(target_os = "macos")]
use core_foundation::base::TCFType;

#[cfg(target_os = "macos")]
use core_foundation::string::CFString;

/// macOS Accessibility API controller using native APIs
pub struct MacAxController {
    // Cache for application elements
    app_cache: std::sync::Mutex<HashMap<String, AXUIElement>>,
}

impl MacAxController {
    pub fn new() -> Result<Self> {
        #[cfg(target_os = "macos")]
        {
            // Check if we have accessibility permissions by trying to get system-wide element
            let _system = AXUIElement::system_wide();

            Ok(Self {
                app_cache: std::sync::Mutex::new(HashMap::new()),
            })
        }

        #[cfg(not(target_os = "macos"))]
        {
            anyhow::bail!("macOS Accessibility API is only available on macOS")
        }
    }

    /// List all running applications
    #[cfg(target_os = "macos")]
    pub fn list_applications(&self) -> Result<Vec<AXApplication>> {
        let apps = Self::get_running_applications()?;
        Ok(apps)
    }

    #[cfg(not(target_os = "macos"))]
    pub fn list_applications(&self) -> Result<Vec<AXApplication>> {
        anyhow::bail!("Not supported on this platform")
    }

    #[cfg(target_os = "macos")]
    fn get_running_applications() -> Result<Vec<AXApplication>> {
        use cocoa::appkit::NSApplicationActivationPolicy;
        use cocoa::base::{id, nil};
        use objc::{class, msg_send, sel, sel_impl};

        unsafe {
            let workspace: id = msg_send![class!(NSWorkspace), sharedWorkspace];
            let running_apps: id = msg_send![workspace, runningApplications];
            let count: usize = msg_send![running_apps, count];

            let mut apps = Vec::new();

            for i in 0..count {
                let app: id = msg_send![running_apps, objectAtIndex: i];

                // Get app name
                let localized_name: id = msg_send![app, localizedName];
                if localized_name == nil {
                    continue;
                }
                let name_ptr: *const i8 = msg_send![localized_name, UTF8String];
                let name = if !name_ptr.is_null() {
                    std::ffi::CStr::from_ptr(name_ptr)
                        .to_string_lossy()
                        .to_string()
                } else {
                    continue;
                };

                // Get bundle ID
                let bundle_id_obj: id = msg_send![app, bundleIdentifier];
                let bundle_id = if bundle_id_obj != nil {
                    let bundle_id_ptr: *const i8 = msg_send![bundle_id_obj, UTF8String];
                    if !bundle_id_ptr.is_null() {
                        Some(
                            std::ffi::CStr::from_ptr(bundle_id_ptr)
                                .to_string_lossy()
                                .to_string(),
                        )
                    } else {
                        None
                    }
                } else {
                    None
                };

                // Get PID
                let pid: i32 = msg_send![app, processIdentifier];

                // Skip background-only apps
                let activation_policy: i64 = msg_send![app, activationPolicy];
                if activation_policy
                    == NSApplicationActivationPolicy::NSApplicationActivationPolicyRegular as i64
                {
                    apps.push(AXApplication {
                        name,
                        bundle_id,
                        pid,
                    });
                }
            }

            Ok(apps)
        }
    }

    /// Get the frontmost (active) application
    #[cfg(target_os = "macos")]
    pub fn get_frontmost_app(&self) -> Result<AXApplication> {
        use cocoa::base::{id, nil};
        use objc::{class, msg_send, sel, sel_impl};

        unsafe {
            let workspace: id = msg_send![class!(NSWorkspace), sharedWorkspace];
            let frontmost_app: id = msg_send![workspace, frontmostApplication];

            if frontmost_app == nil {
                anyhow::bail!("No frontmost application");
            }

            // Get app name
            let localized_name: id = msg_send![frontmost_app, localizedName];
            let name_ptr: *const i8 = msg_send![localized_name, UTF8String];
            let name = std::ffi::CStr::from_ptr(name_ptr)
                .to_string_lossy()
                .to_string();

            // Get bundle ID
            let bundle_id_obj: id = msg_send![frontmost_app, bundleIdentifier];
            let bundle_id = if bundle_id_obj != nil {
                let bundle_id_ptr: *const i8 = msg_send![bundle_id_obj, UTF8String];
                if !bundle_id_ptr.is_null() {
                    Some(
                        std::ffi::CStr::from_ptr(bundle_id_ptr)
                            .to_string_lossy()
                            .to_string(),
                    )
                } else {
                    None
                }
            } else {
                None
            };

            // Get PID
            let pid: i32 = msg_send![frontmost_app, processIdentifier];

            Ok(AXApplication {
                name,
                bundle_id,
                pid,
            })
        }
    }

    #[cfg(not(target_os = "macos"))]
    pub fn get_frontmost_app(&self) -> Result<AXApplication> {
        anyhow::bail!("Not supported on this platform")
    }

    /// Get AXUIElement for an application by name or PID
    #[cfg(target_os = "macos")]
    fn get_app_element(&self, app_name: &str) -> Result<AXUIElement> {
        // Check cache first
        {
            let cache = self.app_cache.lock().unwrap();
            if let Some(element) = cache.get(app_name) {
                return Ok(element.clone());
            }
        }

        // Find the app by name
        let apps = Self::get_running_applications()?;
        let app = apps
            .iter()
            .find(|a| a.name == app_name)
            .ok_or_else(|| anyhow::anyhow!("Application '{}' not found", app_name))?;

        // Create AXUIElement for the app
        let element = AXUIElement::application(app.pid);

        // Cache it
        {
            let mut cache = self.app_cache.lock().unwrap();
            cache.insert(app_name.to_string(), element.clone());
        }

        Ok(element)
    }

    /// Activate (bring to front) an application
    #[cfg(target_os = "macos")]
    pub fn activate_app(&self, app_name: &str) -> Result<()> {
        use cocoa::base::id;
        use objc::{class, msg_send, sel, sel_impl};

        // Find the app
        let apps = Self::get_running_applications()?;
        let app = apps
            .iter()
            .find(|a| a.name == app_name)
            .ok_or_else(|| anyhow::anyhow!("Application '{}' not found", app_name))?;

        unsafe {
            let workspace: id = msg_send![class!(NSWorkspace), sharedWorkspace];
            let running_apps: id = msg_send![workspace, runningApplications];
            let count: usize = msg_send![running_apps, count];

            for i in 0..count {
                let running_app: id = msg_send![running_apps, objectAtIndex: i];
                let pid: i32 = msg_send![running_app, processIdentifier];

                if pid == app.pid {
                    let _: bool = msg_send![running_app, activateWithOptions: 0];
                    return Ok(());
                }
            }
        }

        anyhow::bail!("Failed to activate application")
    }

    #[cfg(not(target_os = "macos"))]
    pub fn activate_app(&self, _app_name: &str) -> Result<()> {
        anyhow::bail!("Not supported on this platform")
    }

    /// Get the UI hierarchy of an application
    #[cfg(target_os = "macos")]
    pub fn get_ui_tree(&self, app_name: &str, max_depth: usize) -> Result<String> {
        let app_element = self.get_app_element(app_name)?;
        let mut output = format!("Application: {}\n", app_name);

        Self::build_ui_tree(&app_element, &mut output, 0, max_depth)?;

        Ok(output)
    }

    #[cfg(not(target_os = "macos"))]
    pub fn get_ui_tree(&self, _app_name: &str, _max_depth: usize) -> Result<String> {
        anyhow::bail!("Not supported on this platform")
    }

    #[cfg(target_os = "macos")]
    fn build_ui_tree(
        element: &AXUIElement,
        output: &mut String,
        depth: usize,
        max_depth: usize,
    ) -> Result<()> {
        if depth >= max_depth {
            return Ok(());
        }

        let indent = "  ".repeat(depth);

        // Get role
        let role = element
            .role()
            .ok()
            .map(|s| s.to_string())
            .unwrap_or_else(|| "Unknown".to_string());

        // Get title
        let title = element.title().ok().map(|s| s.to_string());

        // Get identifier
        let identifier = element.identifier().ok().map(|s| s.to_string());

        // Format output
        output.push_str(&format!("{}Role: {}", indent, role));
        if let Some(t) = title {
            output.push_str(&format!(", Title: {}", t));
        }
        if let Some(id) = identifier {
            output.push_str(&format!(", ID: {}", id));
        }
        output.push('\n');

        // Get children
        if let Ok(children) = element.children() {
            for i in 0..children.len() {
                if let Some(child) = children.get(i) {
                    let _ = Self::build_ui_tree(&child, output, depth + 1, max_depth);
                }
            }
        }

        Ok(())
    }

    /// Find UI elements in an application
    #[cfg(target_os = "macos")]
    pub fn find_elements(
        &self,
        app_name: &str,
        role: Option<&str>,
        title: Option<&str>,
        identifier: Option<&str>,
    ) -> Result<Vec<AXElement>> {
        let app_element = self.get_app_element(app_name)?;
        let mut found_elements = Vec::new();

        let visitor = ElementCollector {
            role_filter: role.map(|s| s.to_string()),
            title_filter: title.map(|s| s.to_string()),
            identifier_filter: identifier.map(|s| s.to_string()),
            results: std::cell::RefCell::new(&mut found_elements),
            depth: std::cell::Cell::new(0),
        };

        let walker = TreeWalker::new();
        walker.walk(&app_element, &visitor);

        Ok(found_elements)
    }

    #[cfg(not(target_os = "macos"))]
    pub fn find_elements(
        &self,
        _app_name: &str,
        _role: Option<&str>,
        _title: Option<&str>,
        _identifier: Option<&str>,
    ) -> Result<Vec<AXElement>> {
        anyhow::bail!("Not supported on this platform")
    }

    /// Find a single element (helper for click, set_value, etc.)
    #[cfg(target_os = "macos")]
    fn find_element(
        &self,
        app_name: &str,
        role: &str,
        title: Option<&str>,
        identifier: Option<&str>,
    ) -> Result<AXUIElement> {
        let app_element = self.get_app_element(app_name)?;

        let role_str = role.to_string();
        let title_str = title.map(|s| s.to_string());
        let identifier_str = identifier.map(|s| s.to_string());

        let finder = ElementFinder::new(
            &app_element,
            move |element| {
                // Check role
                let elem_role = element.role().ok().map(|s| s.to_string());

                if let Some(r) = elem_role {
                    if !r.contains(&role_str) {
                        return false;
                    }
                } else {
                    return false;
                }

                // Check title if specified
                if let Some(ref title_filter) = title_str {
                    let elem_title = element.title().ok().map(|s| s.to_string());

                    if let Some(t) = elem_title {
                        if !t.contains(title_filter) {
                            return false;
                        }
                    } else {
                        return false;
                    }
                }

                // Check identifier if specified
                if let Some(ref id_filter) = identifier_str {
                    let elem_id = element.identifier().ok().map(|s| s.to_string());

                    if let Some(id) = elem_id {
                        if !id.contains(id_filter) {
                            return false;
                        }
                    } else {
                        return false;
                    }
                }

                true
            },
            Some(std::time::Duration::from_secs(2)),
        );

        finder.find().context("Element not found")
    }

    /// Click on a UI element
    #[cfg(target_os = "macos")]
    pub fn click_element(
        &self,
        app_name: &str,
        role: &str,
        title: Option<&str>,
        identifier: Option<&str>,
    ) -> Result<()> {
        let element = self.find_element(app_name, role, title, identifier)?;

        // Perform the press action
        let action_name = CFString::new("AXPress");
        element
            .perform_action(&action_name)
            .map_err(|e| anyhow::anyhow!("Failed to perform press action: {:?}", e))?;

        Ok(())
    }

    #[cfg(not(target_os = "macos"))]
    pub fn click_element(
        &self,
        _app_name: &str,
        _role: &str,
        _title: Option<&str>,
        _identifier: Option<&str>,
    ) -> Result<()> {
        anyhow::bail!("Not supported on this platform")
    }

    /// Set the value of a UI element
    #[cfg(target_os = "macos")]
    pub fn set_value(
        &self,
        app_name: &str,
        role: &str,
        value: &str,
        title: Option<&str>,
        identifier: Option<&str>,
    ) -> Result<()> {
        let element = self.find_element(app_name, role, title, identifier)?;

        // Set the value - convert CFString to CFType
        let cf_value = CFString::new(value);

        element
            .set_value(cf_value.as_CFType())
            .map_err(|e| anyhow::anyhow!("Failed to set value: {:?}", e))?;

        Ok(())
    }

    #[cfg(not(target_os = "macos"))]
    pub fn set_value(
        &self,
        _app_name: &str,
        _role: &str,
        _value: &str,
        _title: Option<&str>,
        _identifier: Option<&str>,
    ) -> Result<()> {
        anyhow::bail!("Not supported on this platform")
    }

    /// Get the value of a UI element
    #[cfg(target_os = "macos")]
    pub fn get_value(
        &self,
        app_name: &str,
        role: &str,
        title: Option<&str>,
        identifier: Option<&str>,
    ) -> Result<String> {
        let element = self.find_element(app_name, role, title, identifier)?;

        // Get the value
        let value_type = element
            .value()
            .map_err(|e| anyhow::anyhow!("Failed to get value: {:?}", e))?;

        // Try to downcast to CFString
        if let Some(cf_string) = value_type.downcast::<CFString>() {
            Ok(cf_string.to_string())
        } else {
            // For non-string values, try to get a description
            Ok(format!("<non-string value>"))
        }
    }

    #[cfg(not(target_os = "macos"))]
    pub fn get_value(
        &self,
        _app_name: &str,
        _role: &str,
        _title: Option<&str>,
        _identifier: Option<&str>,
    ) -> Result<String> {
        anyhow::bail!("Not supported on this platform")
    }

    /// Type text into the currently focused element (uses system text input)
    #[cfg(target_os = "macos")]
    pub fn type_text(&self, app_name: &str, text: &str) -> Result<()> {
        use cocoa::base::{id, nil};
        use cocoa::foundation::NSString;
        use objc::{class, msg_send, sel, sel_impl};

        // First, make sure the app is active
        self.activate_app(app_name)?;

        // Wait for app to fully activate
        std::thread::sleep(std::time::Duration::from_millis(500));

        // Send a Tab key to try to focus on a text field
        // This helps ensure something is focused before we paste
        let _ = self.press_key(app_name, "tab", vec![]);
        std::thread::sleep(std::time::Duration::from_millis(800));

        // Save old clipboard, set new content, paste, then restore
        let old_content: id;
        unsafe {
            // Get the general pasteboard
            let pasteboard: id = msg_send![class!(NSPasteboard), generalPasteboard];

            // Save current clipboard content
            let ns_string_type = NSString::alloc(nil).init_str("public.utf8-plain-text");
            old_content = msg_send![pasteboard, stringForType: ns_string_type];

            // Clear and set new content
            let _: () = msg_send![pasteboard, clearContents];

            let ns_string = NSString::alloc(nil).init_str(text);
            let ns_type = NSString::alloc(nil).init_str("public.utf8-plain-text");
            let _: bool = msg_send![pasteboard, setString:ns_string forType:ns_type];
        }

        // Wait a moment for clipboard to update
        std::thread::sleep(std::time::Duration::from_millis(200));

        // Paste using Cmd+V (outside unsafe block)
        self.press_key(app_name, "v", vec!["command"])?;

        // Wait for paste to complete
        std::thread::sleep(std::time::Duration::from_millis(300));

        // Restore old clipboard content if it existed
        unsafe {
            if old_content != nil {
                let pasteboard: id = msg_send![class!(NSPasteboard), generalPasteboard];
                let _: () = msg_send![pasteboard, clearContents];
                let ns_type = NSString::alloc(nil).init_str("public.utf8-plain-text");
                let _: bool = msg_send![pasteboard, setString:old_content forType:ns_type];
            }
        }

        Ok(())
    }

    #[cfg(not(target_os = "macos"))]
    pub fn type_text(&self, _app_name: &str, _text: &str) -> Result<()> {
        anyhow::bail!("Not supported on this platform")
    }

    /// Focus on a text field or text area element
    #[cfg(target_os = "macos")]
    pub fn focus_element(
        &self,
        app_name: &str,
        role: &str,
        title: Option<&str>,
        identifier: Option<&str>,
    ) -> Result<()> {
        let element = self.find_element(app_name, role, title, identifier)?;

        // Set focused attribute to true
        use core_foundation::boolean::CFBoolean;
        let cf_true = CFBoolean::true_value();

        element
            .set_attribute(&accessibility::AXAttribute::focused(), cf_true)
            .map_err(|e| anyhow::anyhow!("Failed to focus element: {:?}", e))?;

        Ok(())
    }

    /// Press a keyboard shortcut
    #[cfg(target_os = "macos")]
    pub fn press_key(&self, app_name: &str, key: &str, modifiers: Vec<&str>) -> Result<()> {
        use core_graphics::event::{CGEvent, CGEventFlags, CGEventTapLocation};
        use core_graphics::event_source::{CGEventSource, CGEventSourceStateID};

        // First, make sure the app is active
        self.activate_app(app_name)?;

        // Wait a bit for activation
        std::thread::sleep(std::time::Duration::from_millis(100));

        // Map key string to key code
        let key_code =
            Self::key_to_keycode(key).ok_or_else(|| anyhow::anyhow!("Unknown key: {}", key))?;

        // Map modifiers to flags
        let mut flags = CGEventFlags::CGEventFlagNull;
        for modifier in modifiers {
            match modifier.to_lowercase().as_str() {
                "command" | "cmd" => flags |= CGEventFlags::CGEventFlagCommand,
                "option" | "alt" => flags |= CGEventFlags::CGEventFlagAlternate,
                "control" | "ctrl" => flags |= CGEventFlags::CGEventFlagControl,
                "shift" => flags |= CGEventFlags::CGEventFlagShift,
                _ => {}
            }
        }

        // Create event source
        let source = CGEventSource::new(CGEventSourceStateID::HIDSystemState)
            .ok()
            .context("Failed to create event source")?;

        // Create key down event
        let key_down = CGEvent::new_keyboard_event(source.clone(), key_code, true)
            .ok()
            .context("Failed to create key down event")?;
        key_down.set_flags(flags);

        // Create key up event
        let key_up = CGEvent::new_keyboard_event(source, key_code, false)
            .ok()
            .context("Failed to create key up event")?;
        key_up.set_flags(flags);

        // Post events
        key_down.post(CGEventTapLocation::HID);
        std::thread::sleep(std::time::Duration::from_millis(50));
        key_up.post(CGEventTapLocation::HID);

        Ok(())
    }

    #[cfg(not(target_os = "macos"))]
    pub fn press_key(&self, _app_name: &str, _key: &str, _modifiers: Vec<&str>) -> Result<()> {
        anyhow::bail!("Not supported on this platform")
    }

    #[cfg(target_os = "macos")]
    fn key_to_keycode(key: &str) -> Option<u16> {
        // Map common keys to keycodes
        // See: https://eastmanreference.com/complete-list-of-applescript-key-codes
        match key.to_lowercase().as_str() {
            "a" => Some(0x00),
            "s" => Some(0x01),
            "d" => Some(0x02),
            "f" => Some(0x03),
            "h" => Some(0x04),
            "g" => Some(0x05),
            "z" => Some(0x06),
            "x" => Some(0x07),
            "c" => Some(0x08),
            "v" => Some(0x09),
            "b" => Some(0x0B),
            "q" => Some(0x0C),
            "w" => Some(0x0D),
            "e" => Some(0x0E),
            "r" => Some(0x0F),
            "y" => Some(0x10),
            "t" => Some(0x11),
            "1" => Some(0x12),
            "2" => Some(0x13),
            "3" => Some(0x14),
            "4" => Some(0x15),
            "6" => Some(0x16),
            "5" => Some(0x17),
            "=" => Some(0x18),
            "9" => Some(0x19),
            "7" => Some(0x1A),
            "-" => Some(0x1B),
            "8" => Some(0x1C),
            "0" => Some(0x1D),
            "]" => Some(0x1E),
            "o" => Some(0x1F),
            "u" => Some(0x20),
            "[" => Some(0x21),
            "i" => Some(0x22),
            "p" => Some(0x23),
            "return" | "enter" => Some(0x24),
            "l" => Some(0x25),
            "j" => Some(0x26),
            "'" => Some(0x27),
            "k" => Some(0x28),
            ";" => Some(0x29),
            "\\" => Some(0x2A),
            "," => Some(0x2B),
            "/" => Some(0x2C),
            "n" => Some(0x2D),
            "m" => Some(0x2E),
            "." => Some(0x2F),
            "tab" => Some(0x30),
            "space" => Some(0x31),
            "`" => Some(0x32),
            "delete" | "backspace" => Some(0x33),
            "escape" | "esc" => Some(0x35),
            "f1" => Some(0x7A),
            "f2" => Some(0x78),
            "f3" => Some(0x63),
            "f4" => Some(0x76),
            "f5" => Some(0x60),
            "f6" => Some(0x61),
            "f7" => Some(0x62),
            "f8" => Some(0x64),
            "f9" => Some(0x65),
            "f10" => Some(0x6D),
            "f11" => Some(0x67),
            "f12" => Some(0x6F),
            "left" => Some(0x7B),
            "right" => Some(0x7C),
            "down" => Some(0x7D),
            "up" => Some(0x7E),
            _ => None,
        }
    }
}

#[cfg(target_os = "macos")]
struct ElementCollector<'a> {
    role_filter: Option<String>,
    title_filter: Option<String>,
    identifier_filter: Option<String>,
    results: std::cell::RefCell<&'a mut Vec<AXElement>>,
    depth: std::cell::Cell<usize>,
}

#[cfg(target_os = "macos")]
impl<'a> TreeVisitor for ElementCollector<'a> {
    fn enter_element(&self, element: &AXUIElement) -> TreeWalkerFlow {
        self.depth.set(self.depth.get() + 1);

        if self.depth.get() > 20 {
            return TreeWalkerFlow::SkipSubtree;
        }

        // Get element properties
        let role = element
            .role()
            .ok()
            .map(|s| s.to_string())
            .unwrap_or_else(|| "Unknown".to_string());

        let title = element.title().ok().map(|s| s.to_string());

        let identifier = element.identifier().ok().map(|s| s.to_string());

        // Check if this element matches the filters
        let role_matches = self.role_filter.as_ref().map_or(true, |r| role.contains(r));
        let title_matches = self.title_filter.as_ref().map_or(true, |t| {
            title
                .as_ref()
                .map_or(false, |title_str| title_str.contains(t))
        });
        let identifier_matches = self.identifier_filter.as_ref().map_or(true, |id| {
            identifier
                .as_ref()
                .map_or(false, |id_str| id_str.contains(id))
        });

        if role_matches && title_matches && identifier_matches {
            // Get additional properties
            let value = element
                .value()
                .ok()
                .and_then(|v| v.downcast::<CFString>().map(|s| s.to_string()));

            let label = element.description().ok().map(|s| s.to_string());

            let enabled = element.enabled().ok().map(|b| b.into()).unwrap_or(false);

            let focused = element.focused().ok().map(|b| b.into()).unwrap_or(false);

            // Count children
            let children_count = element
                .children()
                .ok()
                .map(|arr| arr.len() as usize)
                .unwrap_or(0);

            self.results.borrow_mut().push(AXElement {
                role,
                title,
                value,
                label,
                identifier,
                enabled,
                focused,
                position: None,
                size: None,
                children_count,
            });
        }

        TreeWalkerFlow::Continue
    }

    fn exit_element(&self, _element: &AXUIElement) {
        self.depth.set(self.depth.get() - 1);
    }
}