MainWindow.xaml.cs

using System;
using System.ComponentModel;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using HandyControl.Controls;
using RSImageProcessor.Models;
using RSImageProcessor.ViewModels;
using RSImageProcessor.Views.Controls;

namespace RSImageProcessor
{
    /// <summary>
    /// MainWindow.xaml 的交互逻辑
    /// </summary>
    public partial class MainWindow : HandyControl.Controls.Window
    {
        private MainViewModel ViewModel => (MainViewModel)DataContext;
        private bool _isUpdatingRenderMode = false;

        public MainWindow()
        {
            InitializeComponent();

            // 设置拖放支持
            AllowDrop = true;
            Drop += MainWindow_Drop;
            DragEnter += MainWindow_DragEnter;

            // 设置键盘快捷键处理
            PreviewKeyDown += MainWindow_PreviewKeyDown;

            // 监听ViewModel属性变化
            Loaded += MainWindow_Loaded;
        }

        private void MainWindow_Loaded(object sender, RoutedEventArgs e)
        {
            // 订阅ViewModel的属性变更事件
            if (ViewModel != null)
            {
                ViewModel.PropertyChanged += ViewModel_PropertyChanged;
            }

            // 监听ImageViewer尺寸变化
            ImageViewer.SizeChanged += ImageViewer_SizeChanged;
            
            // 初始化视口尺寸
            UpdateViewportSize();
        }

        private void ImageViewer_SizeChanged(object sender, SizeChangedEventArgs e)
        {
            UpdateViewportSize();
        }

        private void UpdateViewportSize()
        {
            if (ViewModel != null && ImageViewer.ActualWidth > 0 && ImageViewer.ActualHeight > 0)
            {
                ViewModel.UpdateViewportSize((int)ImageViewer.ActualWidth, (int)ImageViewer.ActualHeight);
            }
        }

        private void ViewModel_PropertyChanged(object? sender, PropertyChangedEventArgs e)
        {
            if (e.PropertyName == nameof(MainViewModel.CurrentRenderMode))
            {
                // 更新渲染模式ComboBox
                UpdateRenderModeComboBox();
            }
        }

        private void UpdateRenderModeComboBox()
        {
            _isUpdatingRenderMode = true;
            try
            {
                // 根据ViewModel的CurrentRenderMode更新ComboBox
                switch (ViewModel.CurrentRenderMode)
                {
                    case RenderMode.Grayscale:
                        RenderModeCombo.SelectedIndex = 0;
                        GrayscalePanel.Visibility = Visibility.Visible;
                        RGBPanel.Visibility = Visibility.Collapsed;
                        break;
                    case RenderMode.RGB:
                        RenderModeCombo.SelectedIndex = 1;
                        GrayscalePanel.Visibility = Visibility.Collapsed;
                        RGBPanel.Visibility = Visibility.Visible;
                        // 更新RGB波段选择框的值
                        if (ViewModel.CurrentImage != null)
                        {
                            RedBandUpDown.Value = ViewModel.CurrentImage.DisplaySettings.RedBandIndex;
                            GreenBandUpDown.Value = ViewModel.CurrentImage.DisplaySettings.GreenBandIndex;
                            BlueBandUpDown.Value = ViewModel.CurrentImage.DisplaySettings.BlueBandIndex;
                        }
                        break;
                    case RenderMode.Pseudocolor:
                        RenderModeCombo.SelectedIndex = 2;
                        GrayscalePanel.Visibility = Visibility.Visible;
                        RGBPanel.Visibility = Visibility.Collapsed;
                        break;
                }
            }
            finally
            {
                _isUpdatingRenderMode = false;
            }
        }

        /// <summary>
        /// 键盘快捷键处理
        /// </summary>
        private void MainWindow_PreviewKeyDown(object sender, System.Windows.Input.KeyEventArgs e)
        {
            if (e.KeyboardDevice.Modifiers == System.Windows.Input.ModifierKeys.Control)
            {
                switch (e.Key)
                {
                    case System.Windows.Input.Key.D0:
                    case System.Windows.Input.Key.NumPad0:
                        ImageViewer.ZoomToFit();
                        e.Handled = true;
                        break;
                    case System.Windows.Input.Key.D1:
                    case System.Windows.Input.Key.NumPad1:
                        ImageViewer.ZoomToActual();
                        e.Handled = true;
                        break;
                }
            }
        }

        #region 事件处理

        /// <summary>
        /// 图像鼠标移动事件
        /// </summary>
        private void ImageViewer_ImageMouseMove(object? sender, ImageMouseEventArgs e)
        {
            // 始终更新位置信息，让 ViewModel 自己处理边界检查
            ViewModel.UpdateMousePosition(e.ImageX, e.ImageY);
        }

        /// <summary>
        /// 渲染模式改变
        /// </summary>
        private void RenderModeCombo_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (!IsLoaded || _isUpdatingRenderMode) return;

            switch (RenderModeCombo.SelectedIndex)
            {
                case 0: // 灰度
                    GrayscalePanel.Visibility = Visibility.Visible;
                    RGBPanel.Visibility = Visibility.Collapsed;
                    if (ViewModel.CurrentImage != null)
                    {
                        ViewModel.SetGrayscaleCommand.Execute((int)ViewModel.SelectedBandIndex);
                    }
                    break;
                case 1: // RGB
                    GrayscalePanel.Visibility = Visibility.Collapsed;
                    RGBPanel.Visibility = Visibility.Visible;
                    if (ViewModel.CurrentImage != null)
                    {
                        // 获取当前RGB波段设置
                        int r = (int)RedBandUpDown.Value;
                        int g = (int)GreenBandUpDown.Value;
                        int b = (int)BlueBandUpDown.Value;
                        ViewModel.SetRGBBandsCommand.Execute($"{r},{g},{b}");
                    }
                    break;
                case 2: // 伪彩色
                    GrayscalePanel.Visibility = Visibility.Visible;
                    RGBPanel.Visibility = Visibility.Collapsed;
                    if (ViewModel.CurrentImage != null)
                    {
                        ViewModel.CurrentImage.DisplaySettings.RenderMode = Models.RenderMode.Pseudocolor;
                        ViewModel.RefreshDisplayCommand.Execute(null);
                    }
                    break;
            }
        }

        /// <summary>
        /// 波段索引改变
        /// </summary>
        private void BandIndex_ValueChanged(object sender, HandyControl.Data.FunctionEventArgs<double> e)
        {
            if (!IsLoaded || ViewModel.CurrentImage == null) return;

            ViewModel.SetGrayscaleCommand.Execute((int)e.Info);
        }

        /// <summary>
        /// 应用RGB波段设置
        /// </summary>
        private void ApplyRGB_Click(object sender, RoutedEventArgs e)
        {
            if (ViewModel.CurrentImage == null) return;

            int r = (int)RedBandUpDown.Value;
            int g = (int)GreenBandUpDown.Value;
            int b = (int)BlueBandUpDown.Value;

            ViewModel.SetRGBBandsCommand.Execute($"{r},{g},{b}");
        }

        /// <summary>
        /// 拉伸方式改变
        /// </summary>
        private void StretchTypeCombo_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (!IsLoaded || ViewModel.CurrentImage == null) return;

            var selectedItem = StretchTypeCombo.SelectedItem as ComboBoxItem;
            if (selectedItem?.Tag == null) return;

            string stretchTag = selectedItem.Tag.ToString() ?? "MinMax";

            // 根据Tag设置拉伸类型
            ViewModel.CurrentImage.DisplaySettings.StretchType = stretchTag switch
            {
                "None" => Models.StretchType.None,
                "MinMax" => Models.StretchType.MinMax,
                "Percent" => Models.StretchType.Percent,
                "StandardDeviation" => Models.StretchType.StandardDeviation,
                "Histogram" => Models.StretchType.Histogram,
                "Linear" => Models.StretchType.Linear,
                "Logarithmic" => Models.StretchType.Logarithmic,
                "SquareRoot" => Models.StretchType.SquareRoot,
                "Sigmoid" => Models.StretchType.Sigmoid,
                _ => Models.StretchType.MinMax
            };

            // 设置拉伸参数
            if (stretchTag == "Percent")
            {
                ViewModel.CurrentImage.DisplaySettings.StretchParameter = 2.0;  // 2% 截断
            }
            else if (stretchTag == "StandardDeviation")
            {
                ViewModel.CurrentImage.DisplaySettings.StretchParameter = 2.0;  // 2个标准差
            }

            // 刷新显示
            ViewModel.RefreshDisplayCommand.Execute(null);
        }

        /// <summary>
        /// 文件拖放进入
        /// </summary>
        private void MainWindow_DragEnter(object sender, DragEventArgs e)
        {
            if (e.Data.GetDataPresent(DataFormats.FileDrop))
            {
                e.Effects = DragDropEffects.Copy;
            }
            else
            {
                e.Effects = DragDropEffects.None;
            }
            e.Handled = true;
        }

        /// <summary>
        /// 文件拖放 - 直接打开拖入的文件
        /// </summary>
        private async void MainWindow_Drop(object sender, DragEventArgs e)
        {
            if (e.Data.GetDataPresent(DataFormats.FileDrop))
            {
                string[]? files = e.Data.GetData(DataFormats.FileDrop) as string[];
                if (files != null && files.Length > 0)
                {
                    // 打开第一个文件
                    string filePath = files[0];
                    if (Core.GdalManager.IsFormatSupported(filePath))
                    {
                        // 直接调用ViewModel的OpenImageFromPathAsync方法
                        await ViewModel.OpenImageFromPathAsync(filePath);
                    }
                    else
                    {
                        Growl.Warning($"不支持的文件格式: {System.IO.Path.GetExtension(filePath)}");
                    }
                }
            }
        }

        /// <summary>
        /// 退出菜单点击
        /// </summary>
        private void Exit_Click(object sender, RoutedEventArgs e)
        {
            Close();
        }

        /// <summary>
        /// 适应窗口按钮点击
        /// </summary>
        private void ZoomToFit_Click(object sender, RoutedEventArgs e)
        {
            ImageViewer.ZoomToFit();
        }

        /// <summary>
        /// 1:1显示按钮点击
        /// </summary>
        private void ZoomToActual_Click(object sender, RoutedEventArgs e)
        {
            ImageViewer.ZoomToActual();
        }

        /// <summary>
        /// 窗口关闭
        /// </summary>
        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            // 清理资源
            ViewModel.Cleanup();
        }

        #endregion

        #region 辅助方法

        /// <summary>
        /// 显示消息
        /// </summary>
        public void ShowMessage(string message, bool isError = false)
        {
            if (isError)
            {
                Growl.Error(message);
            }
            else
            {
                Growl.Info(message);
            }
        }

        /// <summary>
        /// 适应窗口显示
        /// </summary>
        public void ZoomToFit()
        {
            ImageViewer.ZoomToFit();
        }

        #endregion

        #region 波段运算和批量处理

        /// <summary>
        /// 波段运算器
        /// </summary>
        private void BandCalculator_Click(object sender, RoutedEventArgs e)
        {
            if (ViewModel.CurrentImage == null)
            {
                Growl.Warning("请先打开图像");
                return;
            }

            var dialog = new Views.Dialogs.BandCalculatorDialog(ViewModel.CurrentImage.FilePath);
            dialog.Owner = this;
            dialog.ShowDialog();
        }

        /// <summary>
        /// 批量处理
        /// </summary>
        private void BatchProcess_Click(object sender, RoutedEventArgs e)
        {
            var dialog = new Views.Dialogs.BatchProcessDialog();
            dialog.Owner = this;
            dialog.ShowDialog();
        }

        #endregion

        #region 手动裁剪

        /// <summary>
        /// 菜单项：手动裁剪
        /// </summary>
        private void ManualCropMenuItem_Click(object sender, RoutedEventArgs e)
        {
            // 通过菜单触发手动裁剪，设置ToggleButton的状态
            ManualCropToggle.IsChecked = true;
        }

        /// <summary>
        /// 手动裁剪模式开启
        /// </summary>
        private void ManualCropToggle_Checked(object sender, RoutedEventArgs e)
        {
            // 切换到选择模式
            ImageViewer.InteractionMode = InteractionMode.Select;

            // 订阅选择完成事件
            ImageViewer.SelectionCompleted -= ImageViewer_SelectionCompleted;
            ImageViewer.SelectionCompleted += ImageViewer_SelectionCompleted;

            Growl.Info("手动裁剪模式已开启，请在图像上拖动鼠标画框选择裁剪区域");
        }

        /// <summary>
        /// 手动裁剪模式关闭
        /// </summary>
        private void ManualCropToggle_Unchecked(object sender, RoutedEventArgs e)
        {
            // 切换回平移模式
            ImageViewer.InteractionMode = InteractionMode.Pan;
            ImageViewer.ClearSelection();

            // 取消订阅
            ImageViewer.SelectionCompleted -= ImageViewer_SelectionCompleted;
        }

        /// <summary>
        /// 选择框完成事件
        /// </summary>
        private async void ImageViewer_SelectionCompleted(object? sender, SelectionCompletedEventArgs e)
        {
            if (ViewModel.CurrentImage == null) return;

            // 将预览图坐标转换为原始图像坐标
            double scale = ViewModel.CurrentImage.PreviewScale;
            int startX = (int)(e.ImageRect.X / scale);
            int startY = (int)(e.ImageRect.Y / scale);
            int width = (int)(e.ImageRect.Width / scale);
            int height = (int)(e.ImageRect.Height / scale);

            // 确保在图像范围内
            startX = Math.Max(0, startX);
            startY = Math.Max(0, startY);
            width = Math.Min(width, ViewModel.CurrentImage.Width - startX);
            height = Math.Min(height, ViewModel.CurrentImage.Height - startY);

            if (width < 1 || height < 1)
            {
                Growl.Warning("选择区域太小，请重新选择");
                return;
            }

            // 显示确认对话框
            var result = HandyControl.Controls.MessageBox.Show(
                $"确定要裁剪选中的区域吗？\n\n" +
                $"起始位置: ({startX}, {startY})\n" +
                $"尺寸: {width} x {height} 像素",
                "确认裁剪",
                MessageBoxButton.YesNo,
                MessageBoxImage.Question);

            if (result != MessageBoxResult.Yes)
            {
                return;
            }

            // 选择保存路径
            var saveDialog = new Microsoft.Win32.SaveFileDialog
            {
                Title = "保存裁剪结果",
                Filter = "GeoTIFF文件|*.tif|所有文件|*.*",
                DefaultExt = ".tif",
                FileName = System.IO.Path.GetFileNameWithoutExtension(ViewModel.CurrentImage.FileName) + "_cropped.tif"
            };

            if (saveDialog.ShowDialog() != true)
            {
                return;
            }

            // 执行裁剪
            try
            {
                ViewModel.StatusMessage = "正在裁剪图像...";
                ViewModel.IsBusy = true;

                await Task.Run(() =>
                {
                    using var reader = new RSImageProcessor.Core.RasterReader();
                    reader.Open(ViewModel.CurrentImage.FilePath);
                    reader.ClipRaster(saveDialog.FileName, startX, startY, width, height);
                });

                ViewModel.IsBusy = false;
                ViewModel.StatusMessage = "裁剪完成";

                Growl.Success($"裁剪完成！\n保存至: {saveDialog.FileName}");

                // 询问是否打开裁剪后的图像
                var openResult = HandyControl.Controls.MessageBox.Show(
                    "是否打开裁剪后的图像？",
                    "裁剪完成",
                    MessageBoxButton.YesNo,
                    MessageBoxImage.Question);

                if (openResult == MessageBoxResult.Yes)
                {
                    await ViewModel.OpenImageFromPathAsync(saveDialog.FileName);
                }
            }
            catch (Exception ex)
            {
                ViewModel.IsBusy = false;
                ViewModel.StatusMessage = "裁剪失败";
                Growl.Error($"裁剪失败: {ex.Message}");
            }
            finally
            {
                // 关闭手动裁剪模式
                ManualCropToggle.IsChecked = false;
            }
        }

        #endregion

        #region AI功能

        /// <summary>
        /// 图像描述生成
        /// </summary>
        private void ImageDescription_Click(object sender, RoutedEventArgs e)
        {
            string? imagePath = null;
            if (ViewModel.CurrentImage != null)
            {
                imagePath = ViewModel.CurrentImage.FilePath;
            }

            var dialog = new Views.Dialogs.ImageDescriptionDialog(imagePath);
            dialog.Owner = this;
            dialog.ShowDialog();
        }

        /// <summary>
        /// AI图像对话
        /// </summary>
        private void ImageChat_Click(object sender, RoutedEventArgs e)
        {
            string? imagePath = null;
            if (ViewModel.CurrentImage != null)
            {
                imagePath = ViewModel.CurrentImage.FilePath;
            }

            var dialog = new Views.Dialogs.ImageChatDialog(imagePath);
            dialog.Owner = this;
            dialog.ShowDialog();
        }

        /// <summary>
        /// API设置
        /// </summary>
        private void ApiSettings_Click(object sender, RoutedEventArgs e)
        {
            var dialog = new Views.Dialogs.ApiSettingsDialog();
            dialog.Owner = this;
            dialog.ShowDialog();
        }

        #endregion
    }
}