// 画素の行・列の偶奇に対応させるための文字列です。カメラのExposureTimeSelectorに対応。
// 画面の４つの入力欄と同じ順序にして、書き込み先を対応付けます。
private static readonly string[] ExposureSelectors =
{
    "EvenRowEvenColumn",
    "EvenRowOddColumn",
    "OddRowEvenColumn",
    "OddRowOddColumn"
};


private readonly Grabber _grabber = new Grabber();
private readonly Imx900HdrProcessor _hdrProcessor = new Imx900HdrProcessor();
private readonly CameraParameterControl[] _individualExposureControls;
private QueueSink _sink;
private bool _updatingControls;
private bool _cameraControlsReady;
private volatile bool _hdrEnabled;
private volatile bool _darkFrameActive;
private int _darkFrameCommand;
private ExposureFrameSet _displayedFrames;
private bool _snapshotMode;
private string _imageSaveDirectory;
private int _lastFrameErrorTick;
private ExposureFrameSet _pendingFrames;
private readonly System.Windows.Forms.Timer _previewTimer = new System.Windows.Forms.Timer();
private volatile bool _closing;

// ユーザーごとのアプリデータ領域にカメラ設定を保存します。
private string DeviceStatePath
{
    get { return Path.Combine(Application.UserAppDataPath, "imx900hdr.xml"); }
}

private string ImageSaveSettingsPath
{
    get { return Path.Combine(Application.UserAppDataPath, "image-save-settings.xml"); }
}

// 
public Form1()
{
    InitializeComponent();
    _individualExposureControls = new[]
    {
        exposureEvenEven,
        exposureEvenOdd,
        exposureOddEven,
        exposureOddOdd
    };
    // 露光時間を変更したときにカメラに対して反映するイベントを登録します。個別露光は４つの入力欄が同じイベントハンドラを共有します。
    foreach (CameraParameterControl control in _individualExposureControls)
        control.ValueChanged += individualExposure_ValueChanged;

    _sink = new QueueSink(PixelFormat.Mono8); //PixelFormatはMono8で固定します。
    _sink.FramesQueued += Sink_FramesQueued; 
    _previewTimer.Interval = 33;// 約30fpsでGUIスレッドへ表示更新します。
    _previewTimer.Tick += PreviewTimer_Tick;
}

// Form1_Loadは、フォームのロード時に呼び出されます。
// 保存先設定を読み込み、カメラの復元または選択を行い、ライブ表示を開始します。
private void Form1_Load(object sender, EventArgs e)
{
    try { _imageSaveDirectory = ImageSaveSettings.Load(ImageSaveSettingsPath); }
    catch (Exception ex) { SetStatus("保存先設定を読み込めませんでした: " + ex.Message); }
    _previewTimer.Start();

    // 前回のカメラ設定が残っていれば復元を試みます。失敗した場合は選択ダイアログを開きます。
    if (!TryRestoreDevice())
        SelectDevice();

    // 復元または選択に成功した場合は、カメラの現在値をGUIへ反映し、ライブ表示を開始します。
    if (_grabber.IsDeviceValid)
    {
        SetupCameraControls(); // 露光値の入力欄をカメラの現在値で初期化します。
        StartStreaming(); // 6画面ライブ表示を開始します。
    }
    UpdateGUIState(); // 接続・取得・露光モードに応じて、GUI上で操作できるボタンや入力欄を切り替えます。
}

// Form1_FormClosingは、フォームが閉じられるときに呼び出されます。
private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
    _closing = true;
    _previewTimer.Stop();
    _previewTimer.Dispose();
    Interlocked.Exchange(ref _darkFrameCommand, 0); // Dark Frameの取得待ちやリセット待ちを解除します。
    try
    {
        if (_grabber.IsDeviceValid)
        {
            StopStreaming(); // 6画面ライブ表示を停止します。
            Directory.CreateDirectory(Path.GetDirectoryName(DeviceStatePath)); // 保存先フォルダーがない場合は作成します。
            _grabber.DeviceSaveState(DeviceStatePath); // 現在のカメラ設定をIC4固有形式で保存します。
            _grabber.DeviceClose(); // カメラを閉じます。
        }
    }
    catch { }

    if (_sink != null)
    {
        _sink.FramesQueued -= Sink_FramesQueued; // 受信スレッドからの通知を解除します。コールバック関数が呼ばれないようになります。
        _sink.Dispose(); // QueueSinkの内部バッファを解放します。
        _sink = null;
    }
    ClearPreview();
    _hdrProcessor.Dispose();
    _grabber.Dispose();
}

// 前回のカメラ設定が残っていれば復元します。失敗した場合は選択ダイアログを開きます。
private bool TryRestoreDevice()
{
    if (!File.Exists(DeviceStatePath))
        return false;

    try
    {
        _grabber.DeviceOpenFromState(DeviceStatePath); // 前回のカメラ設定を復元します。
        if (_grabber.IsDeviceValid)
            Text = "IMX900 HDR - " + _grabber.DeviceInfo.ModelName;
        return _grabber.IsDeviceValid;
    }
    catch (Exception ex)
    {
        SetStatus("前回のカメラを開けませんでした: " + ex.Message);
        return false;
    }
}

// カメラ選択ダイアログを開き、ユーザーが選択したカメラを接続します。
private bool SelectDevice()
{
    try
    {
        StopStreaming(); // 6画面ライブ表示を停止します。
        ClearPreview(); // 表示をクリアします。
        ResetDarkFrameImmediately(); // Dark Frameの取得待ちやリセット待ちを解除します。
        if (_grabber.IsDeviceValid)
            _grabber.DeviceClose(); // カメラを閉じます。

        ic4.WinForms.Dialogs.ShowDeviceDialog(_grabber, this); // カメラ選択ダイアログを開きます。ユーザーが選択したカメラを接続します。
        if (!_grabber.IsDeviceValid)
            return false;

        Directory.CreateDirectory(Path.GetDirectoryName(DeviceStatePath)); // 保存先フォルダーがない場合は作成します。
        _grabber.DeviceSaveState(DeviceStatePath); // 現在のカメラ設定をIC4固有形式で保存します。
        Text = "IMX900 HDR - " + _grabber.DeviceInfo.ModelName;
        return true;
    }
    catch (Exception ex)
    {
        ShowError("カメラの選択に失敗しました。", ex);
        return false;
    }
}

// 6画面ライブ表示を開始します。
private void StartStreaming()
{
    if (!_grabber.IsDeviceValid) return;
    
    _snapshotMode = false;
    if (_grabber.IsStreaming)
    {
        SetStatus("6画面ライブ表示に戻りました");
        UpdateGUIState(); // 接続・取得・露光モードに応じて、GUI上で操作できるボタンや入力欄を切り替えます。
        return;
    }

    try
    {
        // Mono8以外のPixelFormatでは6画面表示はサポートしません。PropertiesでMono8に変更してください。
        if (_grabber.DevicePropertyMap.GetValueString(PropId.PixelFormat) != "Mono8")
            throw new NotSupportedException("6画面表示はMono8専用です。PropertiesでPixel FormatをMono8にしてください。");
        _grabber.StreamSetup(_sink); // QueueSinkを使用してライブスタートします。
        SetStatus("6画面ライブ表示中: 個別露光4枚 / 平均 / RAW");
    }
    catch (Exception ex)
    {
        ShowError("ライブ表示を開始できませんでした。", ex);
    }
    UpdateGUIState();
}

// 6画面ライブ表示を停止します。
private void StopStreaming()
{
    if (!_grabber.IsDeviceValid || !_grabber.IsStreaming)
        return;

    try { _grabber.StreamStop(); } // 6画面ライブ表示を停止します。
    catch (Exception ex) { SetStatus("ライブ停止エラー: " + ex.Message); }
    UpdateGUIState();
}

// コールバック関数。フレームを受信したタイミングで呼ばれます。
// ここではGUIで表示処理をしません。
private void Sink_FramesQueued(object sender, EventArgs e)
{
    ImageBuffer cameraImage = null;
    ExposureFrameSet frames = null;
    try
    {
        // QueueSinkの内部バッファに残っている最新のフレームだけを取得し、古いフレームは破棄します。
        while (_sink != null && !_sink.IsCancelRequested &&
            _sink.TryPopOutputBuffer(out ImageBuffer queuedImage))
        {
            cameraImage?.Dispose();
            cameraImage = queuedImage;
        }
        if (cameraImage == null || _sink == null || _sink.IsCancelRequested || _closing)
            return;

        ApplyPendingDarkFrameCommand(cameraImage); // Dark Frameの反映をします。
        frames = _hdrProcessor.Process(cameraImage); // 6画面表示するための準備をします。
        ExposureFrameSet previous = Interlocked.Exchange(ref _pendingFrames, frames); // 受信スレッドからGUIスレッドへ表示更新を通知します。
        frames = null; 
        previous?.Dispose();
    }
    catch (Exception ex)
    {
        SetFrameErrorStatusThrottled("画像処理エラー: " + ex.Message);
    }
    finally
    {
        frames?.Dispose();
        cameraImage?.Dispose();
    }
}

// IC4受信スレッドから直接GUIを操作せず、1組の6枚をまとめて表示します。
private void PreviewTimer_Tick(object sender, EventArgs e)
{
    // 固定中は表示を更新しません。受信側は最新の1組だけを保ち、古い組を解放します。
    if (_snapshotMode || _closing) return;
    ExposureFrameSet frames = Interlocked.Exchange(ref _pendingFrames, null); // 受信スレッドからGUIスレッドへ表示更新を通知します。
    if (frames != null) DisplayFrames(frames); // 生成されたframesをDisplayFramesに渡し、表示と保存ができるようにします。
}

// 受信スレッドからの通知で、最新の1組だけを表示します。古い組は解放します。
private void DisplayFrames(ExposureFrameSet frames)
{
    try
    {
        preview.ShowFrames(frames); // 6画面表示用の処理を行います。
        ExposureFrameSet old = _displayedFrames; // 古いフレームを保持します。Disposeする前にGUI表示を更新します。
        _displayedFrames = frames; // 新しいフレームを保持します。Disposeする前にGUI表示を更新します。
        old?.Dispose();
        if (old == null) UpdateGUIState(); // 初回表示時にボタンや入力欄の操作可否を更新します。
    }
    catch (Exception ex)
    {
        frames.Dispose();
        preview.ClearImages();
        _displayedFrames?.Dispose();
        _displayedFrames = null;
        SetFrameErrorStatusThrottled("表示エラー: " + ex.Message);
        UpdateGUIState();
    }
}

private void btnSnap_Click(object sender, EventArgs e)
{
    if (_displayedFrames == null) return;
    _snapshotMode = true;
    ExposureFrameSet latest = Interlocked.Exchange(ref _pendingFrames, null); // 受信スレッドからGUIスレッドへ表示更新を通知します。
    if (latest != null) DisplayFrames(latest); // 最新のフレームを表示します。
    if (_displayedFrames == null) return;
    SetStatus("Snap: 6枚の静止画を表示中です。BMP保存、またはLive Startでライブ表示へ戻れます。");
    UpdateGUIState();
}

// 呼び出し前に取得を停止します。カメラを変更した後に古い画像を残しません。
private void ClearPreview()
{
    Interlocked.Exchange(ref _pendingFrames, null)?.Dispose();
    preview.ClearImages();
    _displayedFrames?.Dispose();
    _displayedFrames = null;
    _snapshotMode = false;
    UpdateGUIState();
}

// 受信スレッドからの通知で、Dark Frameの取得やリセットを反映します。
private void ApplyPendingDarkFrameCommand(ImageBuffer cameraImage)
{
    int command = Interlocked.Exchange(ref _darkFrameCommand, 0);
    if (command > 0)
    {
        _hdrProcessor.SetDarkFrame(cameraImage);
        SetDarkFrameState(true, "Dark Frame: 取得済み");
        SetStatus("Dark Frameを取得しました");
    }
    else if (command < 0)
    {
        _hdrProcessor.ResetDarkFrame();
        SetDarkFrameState(false, "Dark Frame: なし");
        SetStatus("Dark Frameをリセットしました");
    }
}

// カメラの現在値と設定範囲を読み取り、共通露光・個別露光の入力欄を初期化します。
private bool SetupCameraControls()
{
    _cameraControlsReady = false;
    if (!_grabber.IsDeviceValid) return false;
    _updatingControls = true;
    try
    {
        PropertyMap properties = _grabber.DevicePropertyMap;
        // XMLやProperties画面の値を優先します。同期時にAutoや露光値を上書きしません。
        string originalMode = properties.GetValueString(PropId.ExposureTimeMode); // Common / Individual
        string originalSelector = properties.GetValueString(PropId.ExposureTimeSelector); // EvenRowEvenColumn / EvenRowOddColumn / OddRowEvenColumn / OddRowOddColumn
        try
        {
            ConfigureParameter(gainControl, "Gain", properties.Find(PropId.Gain), false, false); // ゲインは小数点を表示します。
            properties.SetValue(PropId.ExposureTimeMode, "Common"); // 共通露光の範囲を読み取るためにモードを切り替えます。
            properties.SetValue(PropId.ExposureTimeSelector, "Common");
            ConfigureParameter(commonExposureControl, "Common Exposure",
                properties.Find(PropId.ExposureTime), true, false);

            properties.SetValue(PropId.ExposureTimeMode, "Individual"); // 個別露光の範囲を読み取るためにモードを切り替えます。
            string[] titles = { "Even / Even", "Even / Odd", "Odd / Even", "Odd / Odd" };
            for (int i = 0; i < ExposureSelectors.Length; i++)
            {
                properties.SetValue(PropId.ExposureTimeSelector, ExposureSelectors[i]);// 個別露光の範囲を読み取るためにSelectorを切り替えます。
                ConfigureParameter(_individualExposureControls[i], titles[i],
                    properties.Find(PropId.ExposureTime), false, true);
            }
        }
        finally
        {
            // 読み取りのため切り替えたモードとSelectorを、元の選択に戻します。
            properties.SetValue(PropId.ExposureTimeMode, originalMode);
            properties.SetValue(PropId.ExposureTimeSelector, originalSelector);
        }
        _hdrEnabled = string.Equals(originalMode, "Individual", StringComparison.OrdinalIgnoreCase);
        radioIndividual.Checked = _hdrEnabled;
        radioCommon.Checked = !_hdrEnabled;
        radioIndividual.Enabled = true;
        _cameraControlsReady = true;
    }
    catch (Exception ex)
    {
        radioIndividual.Enabled = false;
        SetStatus("露光設定を画面に読み込めませんでした: " + ex.Message);
    }
    finally
    {
        _updatingControls = false;
    }

    // 設定の読み直しでは取得済みのDark Frameを保持し、補正を継続します。
    UpdateGUIState();
    return _cameraControlsReady;
}

// カメラが返す範囲・刻み・単位を入力欄に設定します。
// 個別露光では範囲を整数にそろえ、小数点を表示しません。
private static void ConfigureParameter(CameraParameterControl control, string title,
    PropFloat property, bool preferLogarithmic, bool forceInteger)
{
    double minimum = property.Minimum;
    double maximum = property.Maximum;
    double value = property.Value;
    double increment = property.IncrementMode == PropertyIncrementMode.Increment
        ? property.Increment
        : 0.0;
    int precision = forceInteger
        ? 0
        : (int)Math.Max(0, Math.Min(6, property.DisplayPrecision));

    if (forceInteger)
    {
        // カメラの範囲からはみ出さないよう、下限を切り上げ、上限を切り下げます。
        minimum = Math.Ceiling(minimum);
        maximum = Math.Floor(maximum);
        if (maximum < minimum)
            maximum = minimum;
        value = Math.Max(minimum, Math.Min(maximum, Math.Round(value)));
        increment = Math.Max(1.0, Math.Round(increment));
    }

    // 個別露光は整数・線形で操作します。
    // カメラが対数表現を指定していても、個別露光では線形変換を使用します。
    bool logarithmic = !forceInteger && (preferLogarithmic ||
        property.Representation == FloatRepresentation.Logarithmic);
    string unit = string.IsNullOrWhiteSpace(property.Unit) ? string.Empty : " (" + property.Unit + ")";
    control.Configure(title + unit, minimum, maximum, value,
        increment, logarithmic, precision,
        !forceInteger && property.IncrementMode == PropertyIncrementMode.ValueSet
            ? property.ValidValueSet
            : null);
}

// 露光モードを切り替え、選択したモードの画面上の値をカメラへ適用します。
private void SetExposureMode(bool individual)
{
    if (_updatingControls || !_grabber.IsDeviceValid)
        return;

    try
    {
        PropertyMap properties = _grabber.DevicePropertyMap;
        properties.SetValue(PropId.ExposureAuto, "Off"); // 自動露光を無効にします。
        properties.SetValue(PropId.ExposureTimeMode, individual ? "Individual" : "Common"); // 露光モードを切り替えます。
        _hdrEnabled = individual;

        if (individual)
        {
            for (int i = 0; i < ExposureSelectors.Length; i++)
                WriteIndividualExposure(i);　// 個別露光の４つの入力欄の値をカメラへ適用します。
        }
        else
        {
            properties.SetValue(PropId.ExposureTimeSelector, "Common"); // 共通露光の入力欄の値をカメラへ適用します。
            properties.SetValue(PropId.ExposureTime, commonExposureControl.Value); // 共通露光の入力欄の値をカメラへ適用します。
            PropFloat exposure = properties.Find(PropId.ExposureTime); // 適用後の実値を読み戻し、GUI入力欄へ反映します。
            commonExposureControl.SetValueSilently(exposure.Value);
        }
        SetStatus(individual ? "Individual: 4系統の個別露光を6画面で表示" :
            "Common: 共通露光の画像を6画面で表示");
    }
    catch (Exception ex)
    {
        _hdrEnabled = false;
        SetStatus("露光モードの変更に失敗しました: " + ex.Message);
    }
    UpdateGUIState();
}

// 対象の画素グループを選択し、露光値を書き込んで結果を読み戻します。
private void WriteIndividualExposure(int index)
{
    if (!_grabber.IsDeviceValid || !_hdrEnabled || index < 0 || index >= ExposureSelectors.Length)
        return;

    try
    {
        PropertyMap properties = _grabber.DevicePropertyMap; // 個別露光の４つの入力欄の値をカメラへ適用します。
        try { properties.SetValue(PropId.ExposureAuto, "Off"); } catch { } // 自動露光を無効にします。
        properties.SetValue(PropId.ExposureTimeMode, "Individual"); // 個別露光モードに切り替えます。
        // 要求したモードが実際に適用されたことを確認してから個別露光を操作します。
        string appliedMode = properties.GetValueString(PropId.ExposureTimeMode);
        if (!string.Equals(appliedMode, "Individual", StringComparison.OrdinalIgnoreCase))
            throw new InvalidOperationException("ExposureTimeModeをIndividualへ変更できませんでした。");

        properties.SetValue(PropId.ExposureTimeSelector, ExposureSelectors[index]); // 個別露光の範囲を読み取るためにSelectorを切り替えます。
        double requestedValue = Math.Round(_individualExposureControls[index].Value); // 要求された露光値を取得します。
        PropFloat exposure = properties.Find(PropId.ExposureTime);
        // 取得中のロックなどで設定できない状態を確認し、失敗理由を表示できるようにします。
        if (!exposure.IsAvailable)
            throw new InvalidOperationException("選択した個別露光プロパティを利用できません。");
        if (exposure.IsReadonly || exposure.IsLocked)
            throw new InvalidOperationException("選択した個別露光プロパティは現在変更できません。");

        // 変更前後を比較するため現在値を保持し、書き込み後の実値を読み戻します。
        double valueBeforeWrite = exposure.Value;
        exposure.Value = requestedValue;
        double actualAppliedValue = exposure.Value;
        // 読み戻した値も整数表示にそろえます。通知を抑えて書き込みの再発を防ぎます。
        double displayedAppliedValue = Math.Round(actualAppliedValue);
        _individualExposureControls[index].SetValueSilently(displayedAppliedValue);

        // 要求値と適用値を表示します。単位が空文字の場合は表示しません。
        SetStatus(string.Format("{0}: 要求 {1:N0} → 適用 {2:N0} {3}",
            GetExposureDisplayName(index), requestedValue, actualAppliedValue,
            string.IsNullOrWhiteSpace(exposure.Unit) ? "" : exposure.Unit));

        // 丸め誤差を許容しつつ、変更を要求したのに値が変わらない場合を検出します。
        double tolerance = Math.Max(0.5, Math.Abs(requestedValue) * 0.000001);
        if (Math.Abs(requestedValue - valueBeforeWrite) > tolerance &&
            Math.Abs(actualAppliedValue - valueBeforeWrite) <= tolerance)
        {
            throw new InvalidOperationException(
                "カメラが個別露光値の変更を受け付けませんでした。カメラ設定とPixelFormatを確認してください。");
        }

        // 露光変更後も、ユーザーが取得したDark Frameによる補正を維持します。
    }
    catch (Exception ex)
    {
        SetStatus("個別露光の設定に失敗しました: " + ex.Message);
    }
}

// 接続・取得・露光モードに応じて、操作できるボタンや入力欄を切り替えます。
// 受信スレッドから呼ばれた場合は、画面を操作するGUIスレッドへ処理を渡します。
private void UpdateGUIState()
{
    if (InvokeRequired)
    {
        try { BeginInvoke((MethodInvoker)UpdateGUIState); } catch (InvalidOperationException) { }
        return;
    }

    bool valid = _grabber.IsDeviceValid;
    bool streaming = valid && _grabber.IsStreaming;
    btnProperties.Enabled = valid;
    btnSaveSettings.Enabled = valid;
    btnSaveImage.Text = "Save All 6 BMP";
    labelCaptureState.Text = _displayedFrames == null ? "画像なし" :
        (_snapshotMode ? "SNAP：静止画を確認中" : (streaming ? "LIVE" : "STOP：静止画を確認中"));
    labelSaveFolder.Text = string.IsNullOrEmpty(_imageSaveDirectory)
        ? "保存先：未指定（初回保存時に選択）" : "保存先：" + _imageSaveDirectory;
    radioCommon.Enabled = valid && _cameraControlsReady;
    radioIndividual.Enabled = valid && _cameraControlsReady;
    btnLiveStart.Enabled = valid && (!streaming || _snapshotMode);
    btnLiveStop.Enabled = streaming;
    btnSnap.Enabled = _displayedFrames != null && streaming;
    btnSaveImage.Enabled = _displayedFrames != null;
    btnSnapDarkFrame.Enabled = streaming && !_snapshotMode;
    btnResetDarkFrame.Enabled = _darkFrameActive || Volatile.Read(ref _darkFrameCommand) != 0;
    gainControl.Enabled = valid && _cameraControlsReady;
    commonExposureControl.Enabled = valid && _cameraControlsReady && !_hdrEnabled;
    // 個別露光の入力欄は、カメラが接続されていて、カメラの設定が読み込まれ、individual露光モードが有効な場合に操作可能。
    foreach (CameraParameterControl control in _individualExposureControls)
        control.Enabled = valid && _cameraControlsReady && _hdrEnabled;
}

// カメラを選択し直したら、入力範囲を更新してライブ表示を開始します。
private void btnDevice_Click(object sender, EventArgs e)
{
    // カメラ選択ダイアログを開きます。
    if (SelectDevice())
    {
        SetupCameraControls(); // 露光値の入力欄をカメラの現在値で初期化します。
        StartStreaming(); // 6画面ライブ表示を開始します。
    }
    UpdateGUIState(); // 接続・取得・露光モードに応じて、GUI上で操作できるボタンや入力欄を切り替えます。
}

// 標準設定画面を開きます。閉じた後に値を読み直し、画面とカメラを同期します。
private void btnProperties_Click(object sender, EventArgs e)
{
    if (!_grabber.IsDeviceValid) return;
    bool wasStreaming = _grabber.IsStreaming;
    try
    {
        StopStreaming();
        if (_grabber.IsStreaming)
            throw new InvalidOperationException("カメラの取得を停止できませんでした。");
        ClearPreview();
        ic4.WinForms.Dialogs.ShowDevicePropertyDialog(_grabber, this);
        SetupCameraControls();
        Directory.CreateDirectory(Path.GetDirectoryName(DeviceStatePath));
        _grabber.DeviceSaveState(DeviceStatePath);
    }
    catch (Exception ex)
    {
        ShowError("カメラプロパティを開けませんでした。", ex);
    }
    finally
    {
        if (wasStreaming) StartStreaming();
    }
}

// xml形式でカメラ設定を保存します。保存先はユーザーが選択します。
private void btnSaveSettings_Click(object sender, EventArgs e)
{
    if (!_grabber.IsDeviceValid) return;
    using (var dialog = new SaveFileDialog
    {
        Title = "カメラのプロパティ設定をXML保存",
        Filter = "Camera settings (*.xml)|*.xml", DefaultExt = "xml",
        AddExtension = true, FileName = "imx900_settings.xml"
    })
    {
        if (dialog.ShowDialog(this) != DialogResult.OK) return;
        try
        {
            CameraSettingsFile.Save(dialog.FileName, _grabber.DeviceSaveState());
            SetStatus("カメラ設定を保存しました: " + dialog.FileName);
        }
        catch (Exception ex) { ShowError("XML設定を保存できませんでした。", ex); }
    }
}

// xml形式でカメラ設定を読み込みます。読み込んだ設定はカメラに適用されます。
private void btnLoadSettings_Click(object sender, EventArgs e)
{
    using (var dialog = new OpenFileDialog
    {
        Title = "カメラのプロパティ設定をXML読込",
        Filter = "Camera settings (*.xml)|*.xml", CheckFileExists = true
    })
    {
        if (dialog.ShowDialog(this) != DialogResult.OK) return;
        byte[] state;
        try { state = CameraSettingsFile.Load(dialog.FileName); }
        catch (Exception ex)
        {
            ShowError("XML設定を読み込めませんでした。現在の設定は変更していません。", ex);
            return;
        }
        LoadCameraState(state);
    }
}

// 読み込んだXML設定をカメラに適用します。
private void LoadCameraState(byte[] state)
{
    bool wasStreaming = _grabber.IsDeviceValid && _grabber.IsStreaming;
    string originalDevice = _grabber.IsDeviceValid ? _grabber.DeviceInfo.UniqueName : null;
    byte[] backup = null;
    bool deviceChanged = false;
    try
    {
        StopStreaming(); // ライブ表示を停止します。
        if (_grabber.IsStreaming)
            throw new InvalidOperationException("カメラの取得を停止できませんでした。");
        if (_grabber.IsDeviceValid)
            backup = _grabber.DeviceSaveState(); // 現在のカメラ設定をバックアップします。

        ClearPreview(); // 表示をクリアします。
        if (_grabber.IsDeviceValid) _grabber.DeviceClose(); // 接続済みのカメラを閉じてから、設定を復元します。
        deviceChanged = true;
        _grabber.DeviceOpenFromState(state); // XML設定を読み込み、カメラを開きます。
        if (!SetupCameraControls()) // 露光値の入力欄をカメラの現在値で初期化します。
            throw new InvalidOperationException("読み込んだカメラ設定の露光値を確認できませんでした。");
        // 同じカメラへのXML設定読み込みではDark Frameの補正値を保持します。別カメラへのXML設定読み込みでは補正値を解除します。   
        if (!string.Equals(originalDevice, _grabber.DeviceInfo.UniqueName, StringComparison.Ordinal))
            ResetDarkFrameImmediately(); // 別カメラへのXML設定読み込みでは補正値を解除します。
        Text = "IMX900 HDR - " + _grabber.DeviceInfo.ModelName;
        if (wasStreaming) StartStreaming();
        SetStatus("XMLのカメラ設定を読み込みました。停止中の場合はLive Startで表示します。");
    }
    catch (Exception ex)
    {
        string message = "カメラ設定の読み込みに失敗しました。";
        if (deviceChanged)
        {
            try
            {
                if (_grabber.IsDeviceValid) _grabber.DeviceClose();
                if (backup != null)
                {
                    _grabber.DeviceOpenFromState(backup);
                    SetupCameraControls();
                    Text = "IMX900 HDR - " + _grabber.DeviceInfo.ModelName;
                    message += " 元のカメラ設定へ戻しました。";
                }
            }
            catch (Exception restoreError)
            {
                message += " 元の設定の復元にも失敗しました: " + restoreError.Message;
            }
        }
        if (wasStreaming && _grabber.IsDeviceValid) StartStreaming();
        ShowError(message, ex);
    }
    finally { UpdateGUIState(); }
}

// 開始・停止ボタンから共通のストリーム制御処理を呼び出します。
private void btnLiveStart_Click(object sender, EventArgs e) { StartStreaming(); }
private void btnLiveStop_Click(object sender, EventArgs e) { StopStreaming(); }

// 共通露光が選択された場合に、カメラを共通露光モードへ切り替えます。
private void radioCommon_CheckedChanged(object sender, EventArgs e)
{
    if (radioCommon.Checked)
        SetExposureMode(false); // 共通露光モードへ切り替えます。
}

// 個別露光が選択された場合に、カメラを個別露光モードへ切り替えます。
private void radioIndividual_CheckedChanged(object sender, EventArgs e)
{
    if (radioIndividual.Checked)
        SetExposureMode(true);
}

// 手動ゲインを適用して読み戻します。取得済みのDark Frameは保持します。
private void gainControl_ValueChanged(object sender, EventArgs e)
{
    if (_updatingControls || !_grabber.IsDeviceValid)
        return;
    try
    {
        PropertyMap properties = _grabber.DevicePropertyMap; // ゲインの入力欄の値をカメラに適用します。
        try { properties.SetValue(PropId.GainAuto, "Off"); } catch { } // 自動ゲインを無効にします。
        properties.SetValue(PropId.Gain, gainControl.Value); // GUIでの設定値をカメラに適用します。
        gainControl.SetValueSilently(properties.Find(PropId.Gain).Value);
    }
    catch (Exception ex) { SetStatus("ゲイン設定エラー: " + ex.Message); }
}

// Commonモードでのみ共通露光時間を書き込み、設定した値を入力欄へ戻します。
private void commonExposureControl_ValueChanged(object sender, EventArgs e)
{
    if (_updatingControls || !_grabber.IsDeviceValid || _hdrEnabled)
        return;
    try
    {
        PropertyMap properties = _grabber.DevicePropertyMap;
        try { properties.SetValue(PropId.ExposureAuto, "Off"); } catch { }
        properties.SetValue(PropId.ExposureTimeSelector, "Common");
        properties.SetValue(PropId.ExposureTime, commonExposureControl.Value);
        commonExposureControl.SetValueSilently(properties.Find(PropId.ExposureTime).Value);
    }
    catch (Exception ex) { SetStatus("共通露光設定エラー: " + ex.Message); }
}

// 次のフレームをDark Frameにする要求を登録します。取得済みになるまで遮光します。
private void btnSnapDarkFrame_Click(object sender, EventArgs e)
{
    Interlocked.Exchange(ref _darkFrameCommand, 1); // 次のフレームをDark Frameとして取得する要求を登録します。
    labelDarkFrame.Text = "Dark Frame: 取得待ち";
    SetStatus("次のフレームをDark Frameとして取得します...");
    UpdateGUIState(); // 取得待ちの状態に合わせて画面を更新します。
}

// 取得中は次のフレームでリセットします。停止中はフレームを待たずに解除します。
private void btnResetDarkFrame_Click(object sender, EventArgs e)
{
    if (_grabber.IsDeviceValid && _grabber.IsStreaming)
    {
        Interlocked.Exchange(ref _darkFrameCommand, -1);
        labelDarkFrame.Text = "Dark Frame: リセット待ち";
        SetStatus("次のフレームでDark Frameをリセットします...");
    }
    else
    {
        ResetDarkFrameImmediately(); // 停止中はフレームを待たずに解除します。
        SetStatus("Dark Frameをリセットしました");
    }
    UpdateGUIState();
}

// 保留中の要求を取り消し、Dark Frameを解放して状態表示も更新します。
private void ResetDarkFrameImmediately()
{
    Interlocked.Exchange(ref _darkFrameCommand, 0); // 保留中の要求を取り消します。
    _hdrProcessor.ResetDarkFrame(); // Dark Frameを解放します。
    SetDarkFrameState(false, "Dark Frame: なし"); // 状態表示も更新します。
}

// Dark Frameの状態を共有し、表示変更はGUIスレッドで行います。
private void SetDarkFrameState(bool active, string text)
{
    _darkFrameActive = active;
    if (_closing || IsDisposed)
        return;
    if (InvokeRequired)
    {
        try { BeginInvoke((MethodInvoker)delegate { SetDarkFrameState(active, text); }); } // GUIスレッドで表示変更します。
        catch (InvalidOperationException) { }
        return;
    }
    labelDarkFrame.Text = text;
    UpdateGUIState();
}

// 確認中の6枚を保存します。取得停止中でも、保持した画像があれば保存できます。
private void btnSaveImage_Click(object sender, EventArgs e)
{
    if (_displayedFrames == null) return;
    if (string.IsNullOrEmpty(_imageSaveDirectory) && !ChooseImageSaveDirectory()) return;
    if (_displayedFrames == null || _closing) return;
    if (!Directory.Exists(_imageSaveDirectory))
    {
        SetStatus("保存先フォルダーが見つかりません。Save Folderで保存先を変更してください。");
        return;
    }
    // 保存中はGUI側の画像更新が入らないため、確認中の同じ6枚を最後まで保存できます。
    UseWaitCursor = true;
    try
    {
        string savedDirectory = SixFrameExporter.Save(_imageSaveDirectory, _displayedFrames);
        SetStatus("確認中の6枚のBMPを保存しました: " + savedDirectory);
    }
    catch (Exception ex) { SetStatus("BMP保存に失敗しました: " + ex.Message); }
    finally { UseWaitCursor = false; UpdateGUIState(); }
}

// 配列の番号を画面と同じ露光グループ名に変換します。
private static string GetExposureDisplayName(int index)
{
    switch (index)
    {
        case 0: return "Even / Even";
        case 1: return "Even / Odd";
        case 2: return "Odd / Even";
        case 3: return "Odd / Odd";
        default: return "Exposure";
    }
}

public void SetDarkFrame(ImageBuffer cameraImage)
{
    // Mono8で偶数幅・偶数高さの画像であることを確認します。
    ValidateInput(cameraImage);
    // OpenCVのMatに変換してコピーします。カメラの受信バッファは再利用されるため、参照を保持してはいけません。
    using (Mat source = cameraImage.CreateOpenCvWrap())
    {
        Mat replacement = source.Clone(); // コピーして保持します。
        lock (_sync)
        {
            _darkFrame?.Dispose();
            _darkFrame = replacement;
        }
    }
}

public ExposureFrameSet Process(ImageBuffer cameraImage)
{
    // Mono8で偶数幅・偶数高さの画像であることを確認します。
    ValidateInput(cameraImage);
    lock (_sync)
    {
        // 6画面表示用の画像を生成します。途中で例外が発生した場合は、確保したバッファを破棄します。
        var result = new ExposureFrameSet();// 0～3:行・列の偶奇順、4:平均、5:補正前RAW
        try
        {
            using (Mat source = cameraImage.CreateOpenCvWrap()) // OpenCVのMatに変換します。
            using (Mat corrected = source.Clone())// 補正前RAWをコピーします。
            {
                // RAWはDark Frame補正・平均化・明るさ調整をせず、元の画素値をコピーします。
                result.Images[5] = CopyToImageBuffer(source);
                if (_darkFrame != null &&
                    _darkFrame.Size() == corrected.Size() &&
                    _darkFrame.Type() == corrected.Type())
                    Cv2.Subtract(corrected, _darkFrame, corrected);// Dark Frame補正を行います。

                // ４つの露光画像と平均を同じ走査で作り、全画面の撮影時刻をそろえます。
                Mat[] separated = new Mat[5];
                try
                {
                    for (int i = 0; i < separated.Length; i++)
                        separated[i] = new Mat(source.Rows / 2, source.Cols / 2, MatType.CV_8UC1);
                    SplitAndAverage(corrected, separated); // 隣り合う2×2画素から各グループを抜き出し、平均化します。
                    for (int i = 0; i < separated.Length; i++)
                        result.Images[i] = CopyToImageBuffer(separated[i]); // 0～3:行・列の偶奇順、4:平均
                }
                finally
                {
                    foreach (Mat image in separated)
                        image?.Dispose();
                }
            }
            return result;
        }
        catch
        {
            result.Dispose();
            throw;
        }
    }
}

private static unsafe void SplitAndAverage(Mat source, Mat[] output)
{
    // sourceは偶数幅・偶数高さのMono8画像であることを前提とします。
    for (int y = 0; y < source.Rows / 2; y++)
    {
        byte* row0 = (byte*)source.Ptr(y * 2).ToPointer();
        byte* row1 = (byte*)source.Ptr(y * 2 + 1).ToPointer();
        byte* ee = (byte*)output[0].Ptr(y).ToPointer();
        byte* eo = (byte*)output[1].Ptr(y).ToPointer();
        byte* oe = (byte*)output[2].Ptr(y).ToPointer();
        byte* oo = (byte*)output[3].Ptr(y).ToPointer();
        byte* average = (byte*)output[4].Ptr(y).ToPointer();
        // 2×2画素の偶奇位置に応じて４つのグループに分け、平均を計算します。
        for (int x = 0; x < source.Cols / 2; x++)
        {
            ee[x] = row0[x * 2];
            eo[x] = row0[x * 2 + 1];
            oe[x] = row1[x * 2];
            oo[x] = row1[x * 2 + 1];
            // intで加算して255を超える中間値を保持し、4で割って四捨五入します。
            // 露光時間による重み付けや自動正規化はしない単純平均です。
            average[x] = (byte)((ee[x] + eo[x] + oe[x] + oo[x] + 2) / 4);
        }
    }
}

internal void ShowFrames(ExposureFrameSet frames)
{
    // 撮影サイズが変わった場合は、どれか1画面だけでなく全画面をリセットします。
    for (int i = 0; i < _displays.Length; i++)
    {
        var type = frames.Images[i].ImageType; // フレームの幅・高さを取得します。
        if (_viewports[i].ImageSize != new Size((int)type.Width, (int)type.Height))
        {
            ResetAllZoom(); // 撮影サイズが変わった場合は、全画面のズーム・位置をリセットします。
            break;
        }
    }
    // 6画面の表示を更新します。各画面のズーム・位置は共有されます。
    for (int i = 0; i < _displays.Length; i++)
    {
        var type = frames.Images[i].ImageType; // フレームの幅・高さを取得します。
        _viewports[i].SetImageSize(new Size((int)type.Width, (int)type.Height)); // 画像サイズを設定します。
        _viewports[i].Resize(_displays[i].ClientSize); // Displayのクライアントサイズに合わせて表示位置を計算します。
        _viewports[i].SetView(_sharedZoom, _sharedCenterX, _sharedCenterY); // 共有されたズーム・位置を設定します。
        ApplyViewport(i); // Displayに表示位置を反映します。
        _displays[i].DisplayBuffer(frames.Images[i]); // Displayに画像を表示します。
    }
    RefreshCursorPosition(); // マウスが画像の上にある場合は、カーソル表示を更新します。
}

internal void ZoomAllAt(int sourceIndex, Point point, int wheelDelta)
{
    ZoomViewport source = _viewports[sourceIndex]; // 操作元の画面のズーム倍率と中心位置を取得します。
    if (source.Bounds.IsEmpty) return; // 画像がない場合はズーム操作を無視します。
    source.ZoomAt(point, wheelDelta); // 操作元の画面でズームを実行します。
    _sharedZoom = source.Zoom; // 共有されたズーム倍率と中心位置を保持します。
    _sharedCenterX = source.CenterX; // 共有されたズーム倍率と中心位置を保持します。
    _sharedCenterY = source.CenterY; // 共有されたズーム倍率と中心位置を保持します。
    ApplySharedView(); // 共有されたズーム倍率と中心位置を他の5画面に適用します。
}

internal void PanAllBy(int sourceIndex, int deltaX, int deltaY)
{
    if (deltaX == 0 && deltaY == 0) return; // ドラッグしていない場合は何もしません。
    ZoomViewport source = _viewports[sourceIndex]; // 操作元の画面のズーム倍率と中心位置を取得します。
    if (source.Bounds.IsEmpty || source.Zoom <= 1.0) return;
    source.PanBy(deltaX, deltaY); // 操作元の画面でパンを実行します。
    _sharedCenterX = source.CenterX; // 共有された中心位置を保持します。
    _sharedCenterY = source.CenterY; // 共有された中心位置を保持します。
    ApplySharedView(); // 共有されたズーム倍率と中心位置を他の5画面に適用します。
}

private void ApplySharedView()
{
    for (int i = 0; i < _viewports.Length; i++)
    {
        _viewports[i].SetView(_sharedZoom, _sharedCenterX, _sharedCenterY); // 共有されたズーム倍率と中心位置を適用します。
        ApplyViewport(i); // Displayに表示位置を反映します。
    }
    RefreshCursorPosition(); // マウスが画像の上にある場合は、カーソル表示を更新します。
}

internal void UpdateCursorPosition(Point screenPoint)
{
    // 6画面のうち、マウスが乗っている画面を探します。見出しや余白の上ではカーソル位置をクリアします。
    for (int i = 0; i < _displays.Length; i++)
    {
        var display = _displays[i]; 
        if (!display.IsHandleCreated || !display.Visible) continue;
        Point local = display.PointToClient(screenPoint); // 画面座標をDisplayのクライアント座標に変換します。
        Point pixel;

        // Displayのクライアント座標を画像内の画素位置に変換します。見出しや余白の上ではカーソル位置をクリアします。
        if (_viewports[i].TryGetImagePixel(local, out pixel))
        {
            Rectangle bounds = _viewports[i].Bounds;
            // 画素単位で丸める前の位置を共有します。
            SetCursorPosition(i, (local.X - (double)bounds.Left) / bounds.Width,
                (local.Y - (double)bounds.Top) / bounds.Height); 
            return;
        }
    }
    
    ClearCursorPosition(); // マウスが画像の外にある場合は、カーソル表示をクリアします。
}

private void SetCursorPosition(int index, double x, double y)
{
    _hoverIndex = index;
    _cursorX = x;
    _cursorY = y;
    for (int i = 0; i < _viewports.Length; i++)
    {
        if (_labels[i] == null) continue;
        UpdateLabel(i); // 6画面の見出しラベルに、解像度・ズーム倍率・カーソル位置を表示します。
        var display = _displays[i];
        var view = _viewports[i];
        if (index < 0 || view.Bounds.IsEmpty)
            _cursorOverlays[i].Hide(); // マウスが画像の外にある場合は、カーソル表示をクリアします。
        else
            // 6画面のうち、マウスが乗っている画面のインデックスと、共有されたズーム倍率と中心位置を使って、カーソル表示を更新します。
            _cursorOverlays[i].ShowAt(display, view.GetClientPoint(x, y), view.Bounds); 
    }
}

public Point GetImagePixel(double x, double y)
{
    if (ImageSize.IsEmpty) return Point.Empty;
    return new Point(Math.Max(0, Math.Min(ImageSize.Width - 1, (int)(x * ImageSize.Width))),
        Math.Max(0, Math.Min(ImageSize.Height - 1, (int)(y * ImageSize.Height))));
}

public Point GetClientPoint(double x, double y)
{
    return new Point(Bounds.Left + (int)Math.Round(x * Bounds.Width),
        Bounds.Top + (int)Math.Round(y * Bounds.Height));
}

public static string Save(string parentDirectory, ExposureFrameSet frames)
{
    if (frames == null) throw new ArgumentNullException(nameof(frames));
    foreach (ImageBuffer image in frames.Images)
        if (image == null) throw new InvalidOperationException("保存する6枚の画像がそろっていません。");
    if (!Directory.Exists(parentDirectory))
        throw new DirectoryNotFoundException("保存先フォルダーが見つかりません。");

    // GUIDを付けて連続保存でも名前が重ならないようにし、既存の画像は上書きしません。
    string folderName = "imx900_" + DateTime.Now.ToString("yyyyMMdd_HHmmss_fff") +
        "_" + Guid.NewGuid().ToString("N");
    string finalDirectory = Path.Combine(Path.GetFullPath(parentDirectory), folderName);
    string temporaryDirectory = finalDirectory + ".saving";
    Directory.CreateDirectory(temporaryDirectory);
    try
    {
        // 表示用ズームではなく、同じフレームから生成済みの6枚の画素データを保存します。
        // Mono8は8bitモノクロBMPになり、JPEGのような非可逆圧縮は行いません。
        for (int i = 0; i < FileNames.Length; i++)
            frames.Images[i].SaveAsBitmap(Path.Combine(temporaryDirectory, FileNames[i]));

        // 全ファイルが完成した後でフォルダー名を確定し、途中の保存を完了扱いにしません。
        Directory.Move(temporaryDirectory, finalDirectory);
        return finalDirectory;
    }
    catch (Exception saveError)
    {
        try
        {
            // 今回生成した一時ファイルだけを消します。既存の保存フォルダーには触れません。
            foreach (string name in FileNames)
            {
                string file = Path.Combine(temporaryDirectory, name);
                if (File.Exists(file)) File.Delete(file);
            }
            Directory.Delete(temporaryDirectory);
        }
        catch (Exception cleanupError)
        {
            throw new IOException("6枚の保存に失敗しました。一時フォルダーが残っています: " +
                temporaryDirectory + " (" + cleanupError.Message + ")", saveError);
        }
        throw;
    }
}

public static void Save(string path, byte[] deviceState)
{
    if (deviceState == null || deviceState.Length == 0)
        throw new ArgumentException("カメラ設定データが空です。", nameof(deviceState));
    var document = new XDocument(
        new XElement("Imx900CameraSettings", new XAttribute("version", "1"),
            new XElement("DeviceState", new XAttribute("encoding", "base64"),
                Convert.ToBase64String(deviceState))));
    // 一時ファイルが完成してから置き換え、書き込み失敗で既存の設定を壊さないようにします。
    string fullPath = Path.GetFullPath(path);
    string temporaryPath = fullPath + "." + Guid.NewGuid().ToString("N") + ".tmp";
    try
    {
        document.Save(temporaryPath);
        if (File.Exists(fullPath))
            File.Replace(temporaryPath, fullPath, null);
        else
            File.Move(temporaryPath, fullPath);
    }
    finally
    {
        if (File.Exists(temporaryPath)) File.Delete(temporaryPath);
    }
}

public static byte[] Load(string path)
{
    // 外部参照を含むXMLを処理せず、読み込み前にファイル形式を検査します。
    var settings = new XmlReaderSettings
    {
        DtdProcessing = DtdProcessing.Prohibit, XmlResolver = null,
        MaxCharactersInDocument = 16 * 1024 * 1024
    };
    using (XmlReader reader = XmlReader.Create(path, settings))
    {
        var document = XDocument.Load(reader);
        XElement root = document.Root;
        if (root == null || root.Name != "Imx900CameraSettings" ||
            (string)root.Attribute("version") != "1")
            throw new InvalidDataException("このアプリのSave XMLで保存した設定ファイルを選択してください。");
        XElement state = root.Element("DeviceState");
        if (state == null || (string)state.Attribute("encoding") != "base64")
            throw new InvalidDataException("XMLにカメラ設定データがありません。");
        byte[] result = Convert.FromBase64String(state.Value);
        if (result.Length == 0)
            throw new InvalidDataException("カメラ設定データが空です。");
        return result;
    }
}

public static string Load(string settingsPath)
{
    if (!File.Exists(settingsPath)) return null;
    using (var reader = XmlReader.Create(settingsPath, new XmlReaderSettings
    {
        DtdProcessing = DtdProcessing.Prohibit, XmlResolver = null,
        MaxCharactersInDocument = 65536
    }))
    {
        XElement root = XElement.Load(reader);
        if (root.Name != "ImageSaveSettings")
            throw new InvalidDataException("画像保存先の設定形式が正しくありません。");
        string path = (string)root.Element("Directory");
        return string.IsNullOrWhiteSpace(path) ? null : Path.GetFullPath(path);
    }
}

public static void Save(string settingsPath, string directory)
{
    string path = Path.GetFullPath(directory);
    if (!System.IO.Directory.Exists(path))
        throw new DirectoryNotFoundException("画像の保存先フォルダーが見つかりません。");
    System.IO.Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(settingsPath)));
    var xml = new XElement("ImageSaveSettings", new XElement("Directory", path));
    string temporary = settingsPath + "." + Guid.NewGuid().ToString("N") + ".tmp";
    try
    {
        xml.Save(temporary);
        if (File.Exists(settingsPath)) File.Replace(temporary, settingsPath, null);
        else File.Move(temporary, settingsPath);
    }
    finally { if (File.Exists(temporary)) File.Delete(temporary); }
}