// /***************************************************************************
// Aaru Data Preservation Suite
// ----------------------------------------------------------------------------
//
// Filename       : SSC.cs
// Author(s)      : Natalia Portillo <claunia@claunia.com>
//
// Component      : Core algorithms.
//
// --[ Description ] ----------------------------------------------------------
//
//     Dumps media from SCSI Streaming devices.
//
// --[ License ] --------------------------------------------------------------
//
//     This program is free software: you can redistribute it and/or modify
//     it under the terms of the GNU General Public License as
//     published by the Free Software Foundation, either version 3 of the
//     License, or (at your option) any later version.
//
//     This program is distributed in the hope that it will be useful,
//     but WITHOUT ANY WARRANTY; without even the implied warranty of
//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//     GNU General Public License for more details.
//
//     You should have received a copy of the GNU General Public License
//     along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2022 Natalia Portillo
// ****************************************************************************/

// ReSharper disable JoinDeclarationAndInitializer

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using System.Xml.Serialization;
using Aaru.CommonTypes;
using Aaru.CommonTypes.Enums;
using Aaru.CommonTypes.Extents;
using Aaru.CommonTypes.Interfaces;
using Aaru.CommonTypes.Metadata;
using Aaru.CommonTypes.Structs;
using Aaru.Core.Logging;
using Aaru.Decoders.SCSI;
using Aaru.Decoders.SCSI.SSC;
using Aaru.Devices;
using Aaru.Helpers;
using Schemas;
using MediaType = Aaru.CommonTypes.MediaType;
using Version = Aaru.CommonTypes.Interop.Version;

namespace Aaru.Core.Devices.Dumping;

partial class Dump
{
    /// <summary>Dumps the tape from a SCSI Streaming device</summary>
    void Ssc()
    {
        DecodedSense? decSense;
        bool          sense;
        uint          blockSize;
        ulong         blocks = 0;
        MediaType     dskType;
        DateTime      start;
        DateTime      end;
        double        totalDuration = 0;
        double        currentSpeed  = 0;
        double        maxSpeed      = double.MinValue;
        double        minSpeed      = double.MaxValue;
        var           outputTape    = _outputPlugin as IWritableTapeImage;

        _dev.RequestSense(out byte[] senseBuf, _dev.Timeout, out double duration);
        decSense = Sense.Decode(senseBuf);

        InitProgress?.Invoke();

        if(decSense.HasValue &&
           decSense.Value.SenseKey != SenseKeys.NoSense)
        {
            _dumpLog.WriteLine(Localization.Core.Device_not_ready_Sense, decSense.Value.SenseKey, decSense.Value.ASC,
                               decSense.Value.ASCQ);

            StoppingErrorMessage?.Invoke(Localization.Core.Drive_has_status_error_please_correct_Sense_follows +
                                         Environment.NewLine + decSense.Value.Description);

            return;
        }

        // Not in BOM/P
        if(decSense is { ASC: 0x00 }       &&
           decSense.Value.ASCQ     != 0x00 &&
           decSense.Value.ASCQ     != 0x04 &&
           decSense.Value.SenseKey != SenseKeys.IllegalRequest)
        {
            _dumpLog.WriteLine(Localization.Core.Rewinding_please_wait);
            PulseProgress?.Invoke(Localization.Core.Rewinding_please_wait);

            // Rewind, let timeout apply
            _dev.Rewind(out senseBuf, _dev.Timeout, out duration);

            // Still rewinding?
            // TODO: Pause?
            do
            {
                PulseProgress?.Invoke(Localization.Core.Rewinding_please_wait);
                _dev.RequestSense(out senseBuf, _dev.Timeout, out duration);
                decSense = Sense.Decode(senseBuf);
            } while(decSense is { ASC: 0x00, ASCQ: 0x1A or not (0x04 and 0x00) });

            _dev.RequestSense(out senseBuf, _dev.Timeout, out duration);
            decSense = Sense.Decode(senseBuf);

            // And yet, did not rewind!
            if(decSense.HasValue &&
               ((decSense.Value.ASC == 0x00 && decSense.Value.ASCQ != 0x04 && decSense.Value.ASCQ != 0x00) ||
                decSense.Value.ASC != 0x00))
            {
                StoppingErrorMessage?.Invoke(Localization.Core.Drive_could_not_rewind_please_correct_Sense_follows +
                                             Environment.NewLine + decSense.Value.Description);

                _dumpLog.WriteLine(Localization.Core.Drive_could_not_rewind_please_correct_Sense_follows);

                _dumpLog.WriteLine(Localization.Core.Device_not_ready_Sense, decSense.Value.SenseKey,
                                   decSense.Value.ASC, decSense.Value.ASCQ);

                return;
            }
        }

        // Check position
        sense = _dev.ReadPosition(out byte[] cmdBuf, out senseBuf, SscPositionForms.Short, _dev.Timeout, out duration);

        if(sense)
        {
            // READ POSITION is mandatory starting SCSI-2, so do not cry if the drive does not recognize the command (SCSI-1 or earlier)
            // Anyway, <=SCSI-1 tapes do not support partitions
            decSense = Sense.Decode(senseBuf);

            if(decSense.HasValue &&
               ((decSense.Value.ASC == 0x20 && decSense.Value.ASCQ != 0x00) || (decSense.Value.ASC != 0x20 &&
                                                                                       decSense.Value.SenseKey !=
                                                                                       SenseKeys.IllegalRequest)))
            {
                StoppingErrorMessage?.Invoke(Localization.Core.Could_not_get_position_Sense_follows +
                                             Environment.NewLine + decSense.Value.Description);

                _dumpLog.WriteLine(Localization.Core.Could_not_get_position_Sense_follows);

                _dumpLog.WriteLine(Localization.Core.Device_not_ready_Sense, decSense.Value.SenseKey,
                                   decSense.Value.ASC, decSense.Value.ASCQ);

                return;
            }
        }
        else
        {
            // Not in partition 0
            if(cmdBuf[1] != 0)
            {
                UpdateStatus?.Invoke(Localization.Core.Drive_not_in_partition_0_Rewinding_please_wait);
                _dumpLog.WriteLine(Localization.Core.Drive_not_in_partition_0_Rewinding_please_wait);

                // Rewind, let timeout apply
                sense = _dev.Locate(out senseBuf, false, 0, 0, _dev.Timeout, out duration);

                if(sense)
                {
                    StoppingErrorMessage?.Invoke(Localization.Core.Drive_could_not_rewind_please_correct_Sense_follows +
                                                 Environment.NewLine + decSense?.Description);

                    _dumpLog.WriteLine(Localization.Core.Drive_could_not_rewind_please_correct_Sense_follows);

                    _dumpLog.WriteLine(Localization.Core.Device_not_ready_Sense, decSense?.SenseKey, decSense?.ASC,
                                       decSense?.ASCQ);

                    return;
                }

                // Still rewinding?
                // TODO: Pause?
                do
                {
                    Thread.Sleep(1000);
                    PulseProgress?.Invoke(Localization.Core.Rewinding_please_wait);
                    _dev.RequestSense(out senseBuf, _dev.Timeout, out duration);
                    decSense = Sense.Decode(senseBuf);
                } while(decSense is { ASC: 0x00, ASCQ: 0x1A or 0x19 });

                // And yet, did not rewind!
                if(decSense.HasValue &&
                   ((decSense.Value.ASC == 0x00 && decSense.Value.ASCQ != 0x04 && decSense.Value.ASCQ != 0x00) ||
                    decSense.Value.ASC != 0x00))
                {
                    StoppingErrorMessage?.Invoke(Localization.Core.Drive_could_not_rewind_please_correct_Sense_follows +
                                                 Environment.NewLine + decSense.Value.Description);

                    _dumpLog.WriteLine(Localization.Core.Drive_could_not_rewind_please_correct_Sense_follows);

                    _dumpLog.WriteLine(Localization.Core.Device_not_ready_Sense, decSense.Value.SenseKey,
                                       decSense.Value.ASC, decSense.Value.ASCQ);

                    return;
                }

                sense = _dev.ReadPosition(out cmdBuf, out senseBuf, SscPositionForms.Short, _dev.Timeout, out duration);

                if(sense)
                {
                    decSense = Sense.Decode(senseBuf);

                    StoppingErrorMessage?.Invoke(Localization.Core.Drive_could_not_rewind_please_correct_Sense_follows +
                                                 Environment.NewLine + decSense?.Description);

                    _dumpLog.WriteLine(Localization.Core.Drive_could_not_rewind_please_correct_Sense_follows);

                    _dumpLog.WriteLine(Localization.Core.Device_not_ready_Sense, decSense?.SenseKey, decSense?.ASC,
                                       decSense?.ASCQ);

                    return;
                }

                // Still not in partition 0!!!?
                if(cmdBuf[1] != 0)
                {
                    StoppingErrorMessage?.Invoke(Localization.Core.
                                                              Drive_could_not_rewind_to_partition_0_but_no_error_occurred);

                    _dumpLog.WriteLine(Localization.Core.Drive_could_not_rewind_to_partition_0_but_no_error_occurred);

                    return;
                }
            }
        }

        EndProgress?.Invoke();

        byte   scsiMediumTypeTape  = 0;
        byte   scsiDensityCodeTape = 0;
        byte[] mode6Data           = null;
        byte[] mode10Data          = null;

        UpdateStatus?.Invoke(Localization.Core.Requesting_MODE_SENSE_10);

        sense = _dev.ModeSense10(out cmdBuf, out senseBuf, false, true, ScsiModeSensePageControl.Current, 0x3F, 0xFF, 5,
                                 out duration);

        if(!sense ||
           _dev.Error)
            sense = _dev.ModeSense10(out cmdBuf, out senseBuf, false, true, ScsiModeSensePageControl.Current, 0x3F,
                                     0x00, 5, out duration);

        Modes.DecodedMode? decMode = null;

        if(!sense &&
           !_dev.Error)
            if(Modes.DecodeMode10(cmdBuf, _dev.ScsiType).HasValue)
                decMode = Modes.DecodeMode10(cmdBuf, _dev.ScsiType);

        UpdateStatus?.Invoke(Localization.Core.Requesting_MODE_SENSE_6);

        sense = _dev.ModeSense6(out cmdBuf, out senseBuf, false, ScsiModeSensePageControl.Current, 0x3F, 0x00, 5,
                                out duration);

        if(sense || _dev.Error)
            sense = _dev.ModeSense6(out cmdBuf, out senseBuf, false, ScsiModeSensePageControl.Current, 0x3F, 0x00, 5,
                                    out duration);

        if(sense || _dev.Error)
            sense = _dev.ModeSense(out cmdBuf, out senseBuf, 5, out duration);

        if(!sense &&
           !_dev.Error)
            if(Modes.DecodeMode6(cmdBuf, _dev.ScsiType).HasValue)
                decMode = Modes.DecodeMode6(cmdBuf, _dev.ScsiType);

        // TODO: Check partitions page
        if(decMode.HasValue)
        {
            scsiMediumTypeTape = (byte)decMode.Value.Header.MediumType;

            if(decMode.Value.Header.BlockDescriptors?.Length > 0)
                scsiDensityCodeTape = (byte)decMode.Value.Header.BlockDescriptors[0].Density;

            blockSize = decMode.Value.Header.BlockDescriptors?[0].BlockLength ?? 0;

            UpdateStatus?.Invoke(string.Format(Localization.Core.Device_reports_0_blocks, blocks));
        }
        else
            blockSize = 1;

        if(!_dev.ReadBlockLimits(out cmdBuf, out senseBuf, _dev.Timeout, out _))
        {
            BlockLimits.BlockLimitsData? blockLimits = BlockLimits.Decode(cmdBuf);

            if(blockLimits?.minBlockLen > blockSize)
                blockSize = blockLimits?.minBlockLen ?? 0;
        }

        if(blockSize == 0)
            blockSize = 1;

        dskType = MediaTypeFromDevice.GetFromScsi((byte)_dev.ScsiType, _dev.Manufacturer, _dev.Model,
                                                  scsiMediumTypeTape, scsiDensityCodeTape, blocks, blockSize,
                                                  _dev.IsUsb, false);

        if(dskType == MediaType.Unknown)
            dskType = MediaType.UnknownTape;

        UpdateStatus?.Invoke(string.Format(Localization.Core.SCSI_device_type_0, _dev.ScsiType));
        UpdateStatus?.Invoke(string.Format(Localization.Core.SCSI_medium_type_0, scsiMediumTypeTape));
        UpdateStatus?.Invoke(string.Format(Localization.Core.SCSI_density_type_0, scsiDensityCodeTape));
        UpdateStatus?.Invoke(string.Format(Localization.Core.Media_identified_as_0, dskType));

        _dumpLog.WriteLine(Localization.Core.SCSI_device_type_0, _dev.ScsiType);
        _dumpLog.WriteLine(Localization.Core.SCSI_medium_type_0, scsiMediumTypeTape);
        _dumpLog.WriteLine(Localization.Core.SCSI_density_type_0, scsiDensityCodeTape);
        _dumpLog.WriteLine(Localization.Core.Media_identified_as_0, dskType);

        bool  endOfMedia       = false;
        ulong currentBlock     = 0;
        uint  currentFile      = 0;
        byte  currentPartition = 0;
        byte  totalPartitions  = 1; // TODO: Handle partitions.
        bool  fixedLen         = false;
        uint  transferLen      = blockSize;

        firstRead:

        sense = _dev.Read6(out cmdBuf, out senseBuf, false, fixedLen, transferLen, blockSize, _dev.Timeout,
                           out duration);

        if(sense)
        {
            decSense = Sense.Decode(senseBuf);

            if(decSense.HasValue)
                if(decSense.Value.SenseKey == SenseKeys.IllegalRequest)
                {
                    sense = _dev.Space(out senseBuf, SscSpaceCodes.LogicalBlock, -1, _dev.Timeout, out duration);

                    if(sense)
                    {
                        decSense = Sense.Decode(senseBuf);

                        bool eom = decSense?.Fixed?.EOM == true;

                        if(decSense?.Descriptor != null &&
                           decSense.Value.Descriptor.Value.Descriptors.TryGetValue(4, out byte[] sscDescriptor))
                            Sense.DecodeDescriptor04(sscDescriptor, out _, out eom, out _);

                        if(!eom)
                        {
                            StoppingErrorMessage?.Invoke(Localization.Core.Drive_could_not_return_back_Sense_follows +
                                                         Environment.NewLine + decSense.Value.Description);

                            _dumpLog.WriteLine(Localization.Core.Drive_could_not_return_back_Sense_follows);

                            _dumpLog.WriteLine(Localization.Core.Device_not_ready_Sense, decSense.Value.SenseKey,
                                               decSense.Value.ASC, decSense.Value.ASCQ);

                            return;
                        }
                    }

                    fixedLen    = true;
                    transferLen = 1;

                    sense = _dev.Read6(out cmdBuf, out senseBuf, false, fixedLen, transferLen, blockSize, _dev.Timeout,
                                       out duration);

                    if(sense)
                    {
                        decSense = Sense.Decode(senseBuf);

                        StoppingErrorMessage?.Invoke(Localization.Core.Drive_could_not_read_Sense_follows +
                                                     Environment.NewLine + decSense.Value.Description);

                        _dumpLog.WriteLine(Localization.Core.Drive_could_not_read_Sense_follows);

                        _dumpLog.WriteLine(Localization.Core.Device_not_ready_Sense, decSense.Value.SenseKey,
                                           decSense.Value.ASC, decSense.Value.ASCQ);

                        return;
                    }
                }
                else if(decSense.Value.ASC  == 0x00 &&
                        decSense.Value.ASCQ == 0x00)
                {
                    bool ili         = decSense.Value.Fixed?.ILI              == true;
                    bool valid       = decSense.Value.Fixed?.InformationValid == true;
                    uint information = decSense.Value.Fixed?.Information ?? 0;

                    if(decSense.Value.Descriptor.HasValue)
                    {
                        valid = decSense.Value.Descriptor.Value.Descriptors.TryGetValue(0, out byte[] desc00);

                        if(valid)
                            information = (uint)Sense.DecodeDescriptor00(desc00);

                        if(decSense.Value.Descriptor.Value.Descriptors.TryGetValue(4, out byte[] desc04))
                            Sense.DecodeDescriptor04(desc04, out _, out _, out ili);
                    }

                    if(ili && valid)
                    {
                        blockSize = (uint)((int)blockSize -
                                           BitConverter.ToInt32(BitConverter.GetBytes(information), 0));

                        transferLen = blockSize;

                        UpdateStatus?.Invoke(string.Format(Localization.Core.Blocksize_changed_to_0_bytes_at_block_1,
                                                           blockSize, currentBlock));

                        _dumpLog.WriteLine(Localization.Core.Blocksize_changed_to_0_bytes_at_block_1, blockSize,
                                           currentBlock);

                        sense = _dev.Space(out senseBuf, SscSpaceCodes.LogicalBlock, -1, _dev.Timeout, out duration);

                        totalDuration += duration;

                        if(sense)
                        {
                            decSense = Sense.Decode(senseBuf);

                            StoppingErrorMessage?.Invoke(Localization.Core.
                                                                      Drive_could_not_go_back_one_block_Sense_follows +
                                                         Environment.NewLine + decSense.Value.Description);

                            _dumpLog.WriteLine(Localization.Core.Drive_could_not_go_back_one_block_Sense_follows);

                            _dumpLog.WriteLine(Localization.Core.Device_not_ready_Sense, decSense.Value.SenseKey,
                                               decSense.Value.ASC, decSense.Value.ASCQ);

                            return;
                        }

                        goto firstRead;
                    }

                    StoppingErrorMessage?.Invoke(Localization.Core.Drive_could_not_read_Sense_follows +
                                                 Environment.NewLine + decSense.Value.Description);

                    _dumpLog.WriteLine(Localization.Core.Drive_could_not_read_Sense_follows);

                    _dumpLog.WriteLine(Localization.Core.Device_not_ready_Sense, decSense.Value.SenseKey,
                                       decSense.Value.ASC, decSense.Value.ASCQ);

                    return;
                }
                else
                {
                    StoppingErrorMessage?.Invoke(Localization.Core.Drive_could_not_read_Sense_follows +
                                                 Environment.NewLine + decSense.Value.Description);

                    _dumpLog.WriteLine(Localization.Core.Drive_could_not_read_Sense_follows);

                    _dumpLog.WriteLine(Localization.Core.Device_not_ready_Sense, decSense.Value.SenseKey,
                                       decSense.Value.ASC, decSense.Value.ASCQ);

                    return;
                }
            else
            {
                StoppingErrorMessage?.Invoke(Localization.Core.Cannot_read_device_dont_know_why_exiting);
                _dumpLog.WriteLine(Localization.Core.Cannot_read_device_dont_know_why_exiting);

                return;
            }
        }

        sense = _dev.Space(out senseBuf, SscSpaceCodes.LogicalBlock, -1, _dev.Timeout, out duration);

        if(sense)
        {
            decSense = Sense.Decode(senseBuf);

            bool eom = decSense?.Fixed?.EOM == true;

            if(decSense.Value.Descriptor.HasValue &&
               decSense.Value.Descriptor.Value.Descriptors.TryGetValue(4, out byte[] desc04))
                Sense.DecodeDescriptor04(desc04, out _, out eom, out _);

            if(!eom)
            {
                StoppingErrorMessage?.Invoke(Localization.Core.Drive_could_not_return_back_Sense_follows +
                                             Environment.NewLine + decSense.Value.Description);

                _dumpLog.WriteLine(Localization.Core.Drive_could_not_return_back_Sense_follows);

                _dumpLog.WriteLine(Localization.Core.Device_not_ready_Sense, decSense.Value.SenseKey,
                                   decSense.Value.ASC, decSense.Value.ASCQ);

                return;
            }
        }

        DumpHardwareType currentTry = null;
        ExtentsULong     extents    = null;

        ResumeSupport.Process(true, _dev.IsRemovable, blocks, _dev.Manufacturer, _dev.Model, _dev.Serial,
                              _dev.PlatformId, ref _resume, ref currentTry, ref extents, _dev.FirmwareRevision,
                              _private, _force, true);

        if(currentTry == null ||
           extents    == null)
        {
            StoppingErrorMessage?.Invoke(Localization.Core.Could_not_process_resume_file_not_continuing);

            return;
        }

        bool canLocateLong = false;
        bool canLocate     = false;

        UpdateStatus?.Invoke(Localization.Core.Positioning_tape_to_block_1);
        _dumpLog.WriteLine(Localization.Core.Positioning_tape_to_block_1);

        sense = _dev.Locate16(out senseBuf, 1, _dev.Timeout, out _);

        if(!sense)
        {
            sense = _dev.ReadPositionLong(out cmdBuf, out senseBuf, _dev.Timeout, out _);

            if(!sense)
            {
                ulong position = Swapping.Swap(BitConverter.ToUInt64(cmdBuf, 8));

                if(position == 1)
                {
                    canLocateLong = true;
                    UpdateStatus?.Invoke(Localization.Core.LOCATE_LONG_works);
                    _dumpLog.WriteLine(Localization.Core.LOCATE_LONG_works);
                }
            }
        }

        sense = _dev.Locate(out senseBuf, 1, _dev.Timeout, out _);

        if(!sense)
        {
            sense = _dev.ReadPosition(out cmdBuf, out senseBuf, _dev.Timeout, out _);

            if(!sense)
            {
                ulong position = Swapping.Swap(BitConverter.ToUInt32(cmdBuf, 4));

                if(position == 1)
                {
                    canLocate = true;
                    UpdateStatus?.Invoke(Localization.Core.LOCATE_works);
                    _dumpLog.WriteLine(Localization.Core.LOCATE_works);
                }
            }
        }

        if(_resume.NextBlock > 0)
        {
            UpdateStatus?.Invoke(string.Format(Localization.Core.Positioning_tape_to_block_0, _resume.NextBlock));
            _dumpLog.WriteLine(Localization.Core.Positioning_tape_to_block_0, _resume.NextBlock);

            if(canLocateLong)
            {
                sense = _dev.Locate16(out senseBuf, _resume.NextBlock, _dev.Timeout, out _);

                if(!sense)
                {
                    sense = _dev.ReadPositionLong(out cmdBuf, out senseBuf, _dev.Timeout, out _);

                    if(sense)
                    {
                        if(!_force)
                        {
                            _dumpLog.WriteLine(Localization.Core.
                                                            Could_not_check_current_position_unable_to_resume_If_you_want_to_continue_use_force);

                            StoppingErrorMessage?.Invoke(Localization.Core.
                                                                      Could_not_check_current_position_unable_to_resume_If_you_want_to_continue_use_force);

                            return;
                        }

                        _dumpLog.WriteLine(Localization.Core.
                                                        Could_not_check_current_position_unable_to_resume_Dumping_from_the_start);

                        ErrorMessage?.Invoke(Localization.Core.
                                                          Could_not_check_current_position_unable_to_resume_Dumping_from_the_start);

                        canLocateLong = false;
                    }
                    else
                    {
                        ulong position = Swapping.Swap(BitConverter.ToUInt64(cmdBuf, 8));

                        if(position != _resume.NextBlock)
                        {
                            if(!_force)
                            {
                                _dumpLog.WriteLine(Localization.Core.
                                                                Current_position_is_not_as_expected_unable_to_resume_If_you_want_to_continue_use_force);

                                StoppingErrorMessage?.Invoke(Localization.Core.
                                                                          Current_position_is_not_as_expected_unable_to_resume_If_you_want_to_continue_use_force);

                                return;
                            }

                            _dumpLog.WriteLine(Localization.Core.
                                                            Current_position_is_not_as_expected_unable_to_resume_Dumping_from_the_start);

                            ErrorMessage?.Invoke(Localization.Core.
                                                              Current_position_is_not_as_expected_unable_to_resume_Dumping_from_the_start);

                            canLocateLong = false;
                        }
                    }
                }
                else
                {
                    if(!_force)
                    {
                        _dumpLog.WriteLine(Localization.Core.
                                                        Cannot_reposition_tape_unable_to_resume_If_you_want_to_continue_use_force);

                        StoppingErrorMessage?.Invoke(Localization.Core.
                                                                  Cannot_reposition_tape_unable_to_resume_If_you_want_to_continue_use_force);

                        return;
                    }

                    _dumpLog.WriteLine(Localization.Core.
                                                    Cannot_reposition_tape_unable_to_resume_Dumping_from_the_start);

                    ErrorMessage?.Invoke(Localization.Core.
                                                      Cannot_reposition_tape_unable_to_resume_Dumping_from_the_start);

                    canLocateLong = false;
                }
            }
            else if(canLocate)
            {
                sense = _dev.Locate(out senseBuf, (uint)_resume.NextBlock, _dev.Timeout, out _);

                if(!sense)
                {
                    sense = _dev.ReadPosition(out cmdBuf, out senseBuf, _dev.Timeout, out _);

                    if(sense)
                    {
                        if(!_force)
                        {
                            _dumpLog.WriteLine(Localization.Core.
                                                            Could_not_check_current_position_unable_to_resume_If_you_want_to_continue_use_force);

                            StoppingErrorMessage?.Invoke(Localization.Core.
                                                                      Could_not_check_current_position_unable_to_resume_If_you_want_to_continue_use_force);

                            return;
                        }

                        _dumpLog.WriteLine(Localization.Core.
                                                        Could_not_check_current_position_unable_to_resume_Dumping_from_the_start);

                        ErrorMessage?.Invoke(Localization.Core.
                                                          Could_not_check_current_position_unable_to_resume_Dumping_from_the_start);

                        canLocate = false;
                    }
                    else
                    {
                        ulong position = Swapping.Swap(BitConverter.ToUInt32(cmdBuf, 4));

                        if(position != _resume.NextBlock)
                        {
                            if(!_force)
                            {
                                _dumpLog.WriteLine(Localization.Core.
                                                                Current_position_is_not_as_expected_unable_to_resume_If_you_want_to_continue_use_force);

                                StoppingErrorMessage?.Invoke(Localization.Core.
                                                                          Current_position_is_not_as_expected_unable_to_resume_If_you_want_to_continue_use_force);

                                return;
                            }

                            _dumpLog.WriteLine(Localization.Core.
                                                            Current_position_is_not_as_expected_unable_to_resume_Dumping_from_the_start);

                            ErrorMessage?.Invoke(Localization.Core.
                                                              Current_position_is_not_as_expected_unable_to_resume_Dumping_from_the_start);

                            canLocate = false;
                        }
                    }
                }
                else
                {
                    if(!_force)
                    {
                        _dumpLog.WriteLine(Localization.Core.
                                                        Cannot_reposition_tape_unable_to_resume_If_you_want_to_continue_use_force);

                        StoppingErrorMessage?.Invoke(Localization.Core.
                                                                  Cannot_reposition_tape_unable_to_resume_If_you_want_to_continue_use_force);

                        return;
                    }

                    _dumpLog.WriteLine(Localization.Core.
                                                    Cannot_reposition_tape_unable_to_resume_Dumping_from_the_start);

                    ErrorMessage?.Invoke(Localization.Core.
                                                      Cannot_reposition_tape_unable_to_resume_Dumping_from_the_start);

                    canLocate = false;
                }
            }
            else
            {
                if(!_force)
                {
                    _dumpLog.WriteLine(Localization.Core.
                                                    Cannot_reposition_tape_unable_to_resume_If_you_want_to_continue_use_force);

                    StoppingErrorMessage?.Invoke(Localization.Core.
                                                              Cannot_reposition_tape_unable_to_resume_If_you_want_to_continue_use_force);

                    return;
                }

                _dumpLog.WriteLine(Localization.Core.Cannot_reposition_tape_unable_to_resume_Dumping_from_the_start);
                ErrorMessage?.Invoke(Localization.Core.Cannot_reposition_tape_unable_to_resume_Dumping_from_the_start);
                canLocate = false;
            }
        }
        else
        {
            _ = canLocateLong ? _dev.Locate16(out senseBuf, false, 0, 0, _dev.Timeout, out duration)
                    : _dev.Locate(out senseBuf, false, 0, 0, _dev.Timeout, out duration);

            do
            {
                Thread.Sleep(1000);
                PulseProgress?.Invoke(Localization.Core.Rewinding_please_wait);
                _dev.RequestSense(out senseBuf, _dev.Timeout, out duration);
                decSense = Sense.Decode(senseBuf);
            } while(decSense is { ASC: 0x00, ASCQ: 0x1A or 0x19 });

            // And yet, did not rewind!
            if(decSense.HasValue &&
               ((decSense.Value.ASC == 0x00 && decSense.Value.ASCQ != 0x00 && decSense.Value.ASCQ != 0x04) ||
                decSense.Value.ASC != 0x00))
            {
                StoppingErrorMessage?.Invoke(Localization.Core.Drive_could_not_rewind_please_correct_Sense_follows +
                                             Environment.NewLine + decSense.Value.Description);

                _dumpLog.WriteLine(Localization.Core.Drive_could_not_rewind_please_correct_Sense_follows);

                _dumpLog.WriteLine(Localization.Core.Device_not_ready_Sense, decSense.Value.SenseKey,
                                   decSense.Value.ASC, decSense.Value.ASCQ);

                return;
            }
        }

        bool ret = outputTape.SetTape();

        // Cannot set image to tape mode
        if(!ret)
        {
            _dumpLog.WriteLine(Localization.Core.Error_setting_output_image_in_tape_mode_not_continuing);
            _dumpLog.WriteLine(outputTape.ErrorMessage);

            StoppingErrorMessage?.Invoke(Localization.Core.Error_setting_output_image_in_tape_mode_not_continuing +
                                         Environment.NewLine + outputTape.ErrorMessage);

            return;
        }

        ret = outputTape.Create(_outputPath, dskType, _formatOptions, 0, 0);

        // Cannot create image
        if(!ret)
        {
            _dumpLog.WriteLine(Localization.Core.Error_creating_output_image_not_continuing);
            _dumpLog.WriteLine(outputTape.ErrorMessage);

            StoppingErrorMessage?.Invoke(Localization.Core.Error_creating_output_image_not_continuing +
                                         Environment.NewLine + outputTape.ErrorMessage);

            return;
        }

        start = DateTime.UtcNow;
        var mhddLog = new MhddLog(_outputPrefix + ".mhddlog.bin", _dev, blocks, blockSize, 1, _private);
        var ibgLog  = new IbgLog(_outputPrefix  + ".ibg", 0x0008);

        var currentTapeFile = new TapeFile
        {
            File       = currentFile,
            FirstBlock = currentBlock,
            Partition  = currentPartition
        };

        var currentTapePartition = new TapePartition
        {
            Number     = currentPartition,
            FirstBlock = currentBlock
        };

        if((canLocate || canLocateLong) &&
           _resume.NextBlock > 0)
        {
            currentBlock = _resume.NextBlock;

            currentTapeFile =
                outputTape.Files.FirstOrDefault(f => f.LastBlock == outputTape?.Files.Max(g => g.LastBlock));

            currentTapePartition =
                outputTape.TapePartitions.FirstOrDefault(p => p.LastBlock ==
                                                              outputTape?.TapePartitions.Max(g => g.LastBlock));
        }

        if(mode6Data != null)
            outputTape.WriteMediaTag(mode6Data, MediaTagType.SCSI_MODESENSE_6);

        if(mode10Data != null)
            outputTape.WriteMediaTag(mode10Data, MediaTagType.SCSI_MODESENSE_10);

        DateTime timeSpeedStart     = DateTime.UtcNow;
        ulong    currentSpeedSize   = 0;
        double   imageWriteDuration = 0;

        InitProgress?.Invoke();

        while(currentPartition < totalPartitions)
        {
            if(_aborted)
            {
                currentTry.Extents = ExtentsConverter.ToMetadata(extents);
                UpdateStatus?.Invoke(Localization.Core.Aborted);
                _dumpLog.WriteLine(Localization.Core.Aborted);

                break;
            }

            if(endOfMedia)
            {
                UpdateStatus?.Invoke(string.Format(Localization.Core.Finished_partition_0, currentPartition));
                _dumpLog.WriteLine(Localization.Core.Finished_partition_0, currentPartition);

                currentTapeFile.LastBlock = currentBlock - 1;

                if(currentTapeFile.LastBlock > currentTapeFile.FirstBlock)
                    outputTape.AddFile(currentTapeFile);

                currentTapePartition.LastBlock = currentBlock - 1;
                outputTape.AddPartition(currentTapePartition);

                currentPartition++;

                if(currentPartition < totalPartitions)
                {
                    currentFile++;

                    currentTapeFile = new TapeFile
                    {
                        File       = currentFile,
                        FirstBlock = currentBlock,
                        Partition  = currentPartition
                    };

                    currentTapePartition = new TapePartition
                    {
                        Number     = currentPartition,
                        FirstBlock = currentBlock
                    };

                    UpdateStatus?.Invoke(string.Format(Localization.Core.Seeking_to_partition_0, currentPartition));
                    _dev.Locate(out senseBuf, false, currentPartition, 0, _dev.Timeout, out duration);
                    totalDuration += duration;
                }

                continue;
            }

            if(currentSpeed > maxSpeed &&
               currentSpeed > 0)
                maxSpeed = currentSpeed;

            if(currentSpeed < minSpeed &&
               currentSpeed > 0)
                minSpeed = currentSpeed;

            PulseProgress?.Invoke(string.Format(Localization.Core.Reading_block_0_1_MiB_sec, currentBlock,
                                                currentSpeed));

            sense = _dev.Read6(out cmdBuf, out senseBuf, false, fixedLen, transferLen, blockSize, _dev.Timeout,
                               out duration);

            totalDuration += duration;

            if(sense                 &&
               senseBuf?.Length != 0 &&
               !ArrayHelpers.ArrayIsNullOrEmpty(senseBuf))
            {
                decSense = Sense.Decode(senseBuf);

                bool ili         = decSense?.Fixed?.ILI              == true;
                bool valid       = decSense?.Fixed?.InformationValid == true;
                uint information = decSense?.Fixed?.Information ?? 0;
                bool eom         = decSense?.Fixed?.EOM      == true;
                bool filemark    = decSense?.Fixed?.Filemark == true;

                if(decSense?.Descriptor.HasValue == true)
                {
                    if(decSense.Value.Descriptor.Value.Descriptors.TryGetValue(0, out byte[] desc00))
                    {
                        valid       = true;
                        information = (uint)Sense.DecodeDescriptor00(desc00);
                    }

                    if(decSense.Value.Descriptor.Value.Descriptors.TryGetValue(4, out byte[] desc04))
                        Sense.DecodeDescriptor04(desc04, out filemark, out eom, out ili);
                }

                if(decSense.Value.ASC  == 0x00 &&
                   decSense.Value.ASCQ == 0x00 &&
                   ili                         &&
                   valid)
                {
                    blockSize = (uint)((int)blockSize - BitConverter.ToInt32(BitConverter.GetBytes(information), 0));

                    if(!fixedLen)
                        transferLen = blockSize;

                    UpdateStatus?.Invoke(string.Format(Localization.Core.Blocksize_changed_to_0_bytes_at_block_1,
                                                       blockSize, currentBlock));

                    _dumpLog.WriteLine(Localization.Core.Blocksize_changed_to_0_bytes_at_block_1, blockSize,
                                       currentBlock);

                    sense = _dev.Space(out senseBuf, SscSpaceCodes.LogicalBlock, -1, _dev.Timeout, out duration);

                    totalDuration += duration;

                    if(sense)
                    {
                        decSense = Sense.Decode(senseBuf);

                        StoppingErrorMessage?.Invoke(Localization.Core.Drive_could_not_go_back_one_block_Sense_follows +
                                                     Environment.NewLine + decSense.Value.Description);

                        outputTape.Close();
                        _dumpLog.WriteLine(Localization.Core.Drive_could_not_go_back_one_block_Sense_follows);

                        _dumpLog.WriteLine(Localization.Core.Device_not_ready_Sense, decSense.Value.SenseKey,
                                           decSense.Value.ASC, decSense.Value.ASCQ);

                        return;
                    }

                    continue;
                }

                switch(decSense.Value.SenseKey)
                {
                    case SenseKeys.BlankCheck when currentBlock == 0:
                        StoppingErrorMessage?.Invoke(Localization.Core.Cannot_dump_a_blank_tape);
                        outputTape.Close();
                        _dumpLog.WriteLine(Localization.Core.Cannot_dump_a_blank_tape);

                        return;

                    // For sure this is an end-of-tape/partition
                    case SenseKeys.BlankCheck when decSense.Value.ASC == 0x00 &&
                                                   (decSense.Value.ASCQ is 0x02 or 0x05 || eom):
                        // TODO: Detect end of partition
                        endOfMedia = true;
                        UpdateStatus?.Invoke(Localization.Core.Found_end_of_tape_partition);
                        _dumpLog.WriteLine(Localization.Core.Found_end_of_tape_partition);

                        continue;
                    case SenseKeys.BlankCheck:
                        StoppingErrorMessage?.Invoke(Localization.Core.Blank_block_found_end_of_tape);
                        endOfMedia = true;
                        _dumpLog.WriteLine(Localization.Core.Blank_block_found_end_of_tape);

                        continue;
                }

                switch(decSense.Value.SenseKey)
                {
                    case SenseKeys.NoSense or SenseKeys.RecoveredError when decSense.Value.ASCQ is 0x02 or 0x05 || eom:
                        // TODO: Detect end of partition
                        endOfMedia = true;
                        UpdateStatus?.Invoke(Localization.Core.Found_end_of_tape_partition);
                        _dumpLog.WriteLine(Localization.Core.Found_end_of_tape_partition);

                        continue;
                    case SenseKeys.NoSense or SenseKeys.RecoveredError when decSense.Value.ASCQ == 0x01 || filemark:
                        currentTapeFile.LastBlock = currentBlock - 1;
                        outputTape.AddFile(currentTapeFile);

                        currentFile++;

                        currentTapeFile = new TapeFile
                        {
                            File       = currentFile,
                            FirstBlock = currentBlock,
                            Partition  = currentPartition
                        };

                        UpdateStatus?.Invoke(string.Format(Localization.Core.Changed_to_file_0_at_block_1, currentFile,
                                                           currentBlock));

                        _dumpLog.WriteLine(Localization.Core.Changed_to_file_0_at_block_1, currentFile, currentBlock);

                        continue;
                }

                if(decSense is null)
                {
                    StoppingErrorMessage?.
                        Invoke(string.Format(Localization.Core.Drive_could_not_read_block_0_Sense_cannot_be_decoded_look_at_log_for_dump,
                                             currentBlock));

                    _dumpLog.WriteLine(string.Format(Localization.Core.Drive_could_not_read_block_0_Sense_bytes_follow,
                                                     currentBlock));

                    _dumpLog.WriteLine(PrintHex.ByteArrayToHexArrayString(senseBuf, 32));
                }
                else
                {
                    StoppingErrorMessage?.
                        Invoke(string.Format(Localization.Core.Drive_could_not_read_block_0_Sense_follow_1_2,
                                             currentBlock, decSense.Value.SenseKey, decSense.Value.Description));

                    _dumpLog.WriteLine(string.Format(Localization.Core.Drive_could_not_read_block_0_Sense_follows,
                                                     currentBlock));

                    _dumpLog.WriteLine(Localization.Core.Device_not_ready_Sense, decSense.Value.SenseKey,
                                       decSense.Value.ASC, decSense.Value.ASCQ);
                }

                // TODO: Reset device after X errors
                if(_stopOnError)
                    return; // TODO: Return more cleanly

                // Write empty data
                DateTime writeStart = DateTime.Now;
                outputTape.WriteSector(new byte[blockSize], currentBlock);
                imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;

                mhddLog.Write(currentBlock, duration < 500 ? 65535 : duration);
                ibgLog.Write(currentBlock, 0);
                _resume.BadBlocks.Add(currentBlock);
            }
            else
            {
                mhddLog.Write(currentBlock, duration);
                ibgLog.Write(currentBlock, currentSpeed * 1024);
                DateTime writeStart = DateTime.Now;
                outputTape.WriteSector(cmdBuf, currentBlock);
                imageWriteDuration += (DateTime.Now - writeStart).TotalSeconds;
                extents.Add(currentBlock, 1, true);
            }

            currentBlock++;
            _resume.NextBlock++;
            currentSpeedSize += blockSize;

            double elapsed = (DateTime.UtcNow - timeSpeedStart).TotalSeconds;

            if(elapsed <= 0)
                continue;

            currentSpeed     = currentSpeedSize / (1048576 * elapsed);
            currentSpeedSize = 0;
            timeSpeedStart   = DateTime.UtcNow;
        }

        _resume.BadBlocks = _resume.BadBlocks.Distinct().ToList();
        blocks            = currentBlock + 1;
        end               = DateTime.UtcNow;

        // If not aborted this is added at the end of medium
        if(_aborted)
        {
            currentTapeFile.LastBlock = currentBlock - 1;
            outputTape.AddFile(currentTapeFile);

            currentTapePartition.LastBlock = currentBlock - 1;
            outputTape.AddPartition(currentTapePartition);
        }

        EndProgress?.Invoke();
        mhddLog.Close();

        ibgLog.Close(_dev, blocks, blockSize, (end - start).TotalSeconds, currentSpeed * 1024,
                     blockSize * (double)(blocks + 1) / 1024 / (totalDuration / 1000), _devicePath);

        UpdateStatus?.Invoke(string.Format(Localization.Core.Dump_finished_in_0_seconds, (end - start).TotalSeconds));

        UpdateStatus?.Invoke(string.Format(Localization.Core.Average_dump_speed_0_KiB_sec,
                                           blockSize * (double)(blocks + 1) / 1024 / (totalDuration / 1000)));

        UpdateStatus?.Invoke(string.Format(Localization.Core.Average_write_speed_0_KiB_sec,
                                           blockSize * (double)(blocks + 1) / 1024 / imageWriteDuration));

        _dumpLog.WriteLine(Localization.Core.Dump_finished_in_0_seconds, (end - start).TotalSeconds);

        _dumpLog.WriteLine(Localization.Core.Average_dump_speed_0_KiB_sec,
                           blockSize * (double)(blocks + 1) / 1024 / (totalDuration / 1000));

        _dumpLog.WriteLine(Localization.Core.Average_write_speed_0_KiB_sec,
                           blockSize * (double)(blocks + 1) / 1024 / imageWriteDuration);

        #region Error handling
        if(_resume.BadBlocks.Count > 0 &&
           !_aborted                   &&
           _retryPasses > 0            &&
           (canLocate || canLocateLong))
        {
            int        pass              = 1;
            bool       forward           = false;
            const bool runningPersistent = false;

            Modes.ModePage? currentModePage = null;

            if(_persistent)
            {
                // TODO: Implement persistent
            }

            InitProgress?.Invoke();
            repeatRetry:
            ulong[] tmpArray = _resume.BadBlocks.ToArray();

            foreach(ulong badBlock in tmpArray)
            {
                if(_aborted)
                {
                    currentTry.Extents = ExtentsConverter.ToMetadata(extents);
                    UpdateStatus?.Invoke(Localization.Core.Aborted);
                    _dumpLog.WriteLine(Localization.Core.Aborted);

                    break;
                }

                if(forward)
                    PulseProgress?.Invoke(runningPersistent
                                              ? string.
                                                  Format(Localization.Core.Retrying_sector_0_pass_1_recovering_partial_data_forward,
                                                         badBlock, pass)
                                              : string.Format(Localization.Core.Retrying_sector_0_pass_1_forward,
                                                              badBlock, pass));
                else
                    PulseProgress?.Invoke(runningPersistent
                                              ? string.
                                                  Format(Localization.Core.Retrying_sector_0_pass_1_recovering_partial_data_reverse,
                                                         badBlock, pass)
                                              : string.Format(Localization.Core.Retrying_sector_0_pass_1_reverse,
                                                              badBlock, pass));

                UpdateStatus?.Invoke(string.Format(Localization.Core.Positioning_tape_to_block_0, badBlock));
                _dumpLog.WriteLine(string.Format(Localization.Core.Positioning_tape_to_block_0, badBlock));

                if(canLocateLong)
                {
                    sense = _dev.Locate16(out senseBuf, _resume.NextBlock, _dev.Timeout, out _);

                    if(!sense)
                    {
                        sense = _dev.ReadPositionLong(out cmdBuf, out senseBuf, _dev.Timeout, out _);

                        if(sense)
                        {
                            _dumpLog.WriteLine(Localization.Core.Could_not_check_current_position_continuing);
                            StoppingErrorMessage?.Invoke(Localization.Core.Could_not_check_current_position_continuing);

                            continue;
                        }

                        ulong position = Swapping.Swap(BitConverter.ToUInt64(cmdBuf, 8));

                        if(position != _resume.NextBlock)
                        {
                            _dumpLog.WriteLine(Localization.Core.Current_position_is_not_as_expected_continuing);

                            StoppingErrorMessage?.Invoke(Localization.Core.
                                                                      Current_position_is_not_as_expected_continuing);

                            continue;
                        }
                    }
                    else
                    {
                        _dumpLog.WriteLine(string.Format(Localization.Core.Cannot_position_tape_to_block_0, badBlock));

                        ErrorMessage?.Invoke(string.Format(Localization.Core.Cannot_position_tape_to_block_0,
                                                           badBlock));

                        continue;
                    }
                }
                else
                {
                    sense = _dev.Locate(out senseBuf, (uint)_resume.NextBlock, _dev.Timeout, out _);

                    if(!sense)
                    {
                        sense = _dev.ReadPosition(out cmdBuf, out senseBuf, _dev.Timeout, out _);

                        if(sense)
                        {
                            _dumpLog.WriteLine(Localization.Core.Could_not_check_current_position_continuing);
                            StoppingErrorMessage?.Invoke(Localization.Core.Could_not_check_current_position_continuing);

                            continue;
                        }

                        ulong position = Swapping.Swap(BitConverter.ToUInt32(cmdBuf, 4));

                        if(position != _resume.NextBlock)
                        {
                            _dumpLog.WriteLine(Localization.Core.Current_position_is_not_as_expected_continuing);

                            StoppingErrorMessage?.Invoke(Localization.Core.
                                                                      Current_position_is_not_as_expected_continuing);

                            continue;
                        }
                    }
                    else
                    {
                        _dumpLog.WriteLine(string.Format(Localization.Core.Cannot_position_tape_to_block_0, badBlock));

                        ErrorMessage?.Invoke(string.Format(Localization.Core.Cannot_position_tape_to_block_0,
                                                           badBlock));

                        continue;
                    }
                }

                sense = _dev.Read6(out cmdBuf, out senseBuf, false, fixedLen, transferLen, blockSize, _dev.Timeout,
                                   out duration);

                totalDuration += duration;

                if(!sense &&
                   !_dev.Error)
                {
                    _resume.BadBlocks.Remove(badBlock);
                    extents.Add(badBlock);
                    outputTape.WriteSector(cmdBuf, badBlock);

                    UpdateStatus?.Invoke(string.Format(Localization.Core.Correctly_retried_block_0_in_pass_1, badBlock,
                                                       pass));

                    _dumpLog.WriteLine(Localization.Core.Correctly_retried_block_0_in_pass_1, badBlock, pass);
                }
                else if(runningPersistent)
                    outputTape.WriteSector(cmdBuf, badBlock);
            }

            if(pass < _retryPasses &&
               !_aborted           &&
               _resume.BadBlocks.Count > 0)
            {
                pass++;
                forward = !forward;
                _resume.BadBlocks.Sort();

                if(!forward)
                    _resume.BadBlocks.Reverse();

                goto repeatRetry;
            }

            if(runningPersistent && currentModePage.HasValue)
            {
                // TODO: Persistent mode
            }

            EndProgress?.Invoke();
        }
        #endregion Error handling

        _resume.BadBlocks.Sort();

        foreach(ulong bad in _resume.BadBlocks)
            _dumpLog.WriteLine(Localization.Core.Block_0_could_not_be_read, bad);

        currentTry.Extents = ExtentsConverter.ToMetadata(extents);

        outputTape.SetDumpHardware(_resume.Tries);

        // TODO: Media Serial Number
        var metadata = new CommonTypes.Structs.ImageInfo
        {
            Application        = "Aaru",
            ApplicationVersion = Version.GetVersion()
        };

        if(!outputTape.SetMetadata(metadata))
            ErrorMessage?.Invoke(Localization.Core.Error_0_setting_metadata + Environment.NewLine +
                                 outputTape.ErrorMessage);

        if(_preSidecar != null)
            outputTape.SetCicmMetadata(_preSidecar);

        _dumpLog.WriteLine(Localization.Core.Closing_output_file);
        UpdateStatus?.Invoke(Localization.Core.Closing_output_file);
        DateTime closeStart = DateTime.Now;
        outputTape.Close();
        DateTime closeEnd = DateTime.Now;

        UpdateStatus?.Invoke(string.Format(Localization.Core.Closed_in_0_seconds,
                                           (closeEnd - closeStart).TotalSeconds));

        _dumpLog.WriteLine(Localization.Core.Closed_in_0_seconds, (closeEnd - closeStart).TotalSeconds);

        if(_aborted)
        {
            UpdateStatus?.Invoke(Localization.Core.Aborted);
            _dumpLog.WriteLine(Localization.Core.Aborted);

            return;
        }

        if(_aborted)
        {
            UpdateStatus?.Invoke(Localization.Core.Aborted);
            _dumpLog.WriteLine(Localization.Core.Aborted);

            return;
        }

        double totalChkDuration = 0;

        if(_metadata)
        {
            UpdateStatus?.Invoke(Localization.Core.Creating_sidecar);
            _dumpLog.WriteLine(Localization.Core.Creating_sidecar);
            var         filters     = new FiltersList();
            IFilter     filter      = filters.GetFilter(_outputPath);
            var         inputPlugin = ImageFormat.Detect(filter) as IMediaImage;
            ErrorNumber opened      = inputPlugin.Open(filter);

            if(opened != ErrorNumber.NoError)
            {
                StoppingErrorMessage?.Invoke(string.Format(Localization.Core.Error_0_opening_created_image, opened));

                return;
            }

            DateTime chkStart = DateTime.UtcNow;
            _sidecarClass                      =  new Sidecar(inputPlugin, _outputPath, filter.Id, _encoding);
            _sidecarClass.InitProgressEvent    += InitProgress;
            _sidecarClass.UpdateProgressEvent  += UpdateProgress;
            _sidecarClass.EndProgressEvent     += EndProgress;
            _sidecarClass.InitProgressEvent2   += InitProgress2;
            _sidecarClass.UpdateProgressEvent2 += UpdateProgress2;
            _sidecarClass.EndProgressEvent2    += EndProgress2;
            _sidecarClass.UpdateStatusEvent    += UpdateStatus;
            CICMMetadataType sidecar = _sidecarClass.Create();
            end = DateTime.UtcNow;

            if(!_aborted)
            {
                totalChkDuration = (end - chkStart).TotalMilliseconds;

                UpdateStatus?.Invoke(string.Format(Localization.Core.Sidecar_created_in_0_seconds,
                                                   (end - chkStart).TotalSeconds));

                UpdateStatus?.Invoke(string.Format(Localization.Core.Average_checksum_speed_0_KiB_sec,
                                                   blockSize * (double)(blocks + 1) / 1024 /
                                                   (totalChkDuration / 1000)));

                _dumpLog.WriteLine(Localization.Core.Sidecar_created_in_0_seconds, (end - chkStart).TotalSeconds);

                _dumpLog.WriteLine(Localization.Core.Average_checksum_speed_0_KiB_sec,
                                   blockSize * (double)(blocks + 1) / 1024 / (totalChkDuration / 1000));

                if(_preSidecar != null)
                {
                    _preSidecar.BlockMedia = sidecar.BlockMedia;
                    sidecar                = _preSidecar;
                }

                List<(ulong start, string type)> filesystems = new();

                if(sidecar.BlockMedia[0].FileSystemInformation != null)
                    filesystems.AddRange(from partition in sidecar.BlockMedia[0].FileSystemInformation
                                         where partition.FileSystems != null from fileSystem in partition.FileSystems
                                         select (partition.StartSector, fileSystem.Type));

                if(filesystems.Count > 0)
                    foreach(var filesystem in filesystems.Select(o => new
                            {
                                o.start,
                                o.type
                            }).Distinct())
                    {
                        UpdateStatus?.Invoke(string.Format(Localization.Core.Found_filesystem_0_at_sector_1,
                                                           filesystem.type, filesystem.start));

                        _dumpLog.WriteLine(Localization.Core.Found_filesystem_0_at_sector_1, filesystem.type,
                                           filesystem.start);
                    }

                sidecar.BlockMedia[0].Dimensions = Dimensions.DimensionsFromMediaType(dskType);

                (string type, string subType) xmlType = CommonTypes.Metadata.MediaType.MediaTypeToString(dskType);

                sidecar.BlockMedia[0].DiskType    = xmlType.type;
                sidecar.BlockMedia[0].DiskSubType = xmlType.subType;

                // TODO: Implement device firmware revision
                if(!_dev.IsRemovable ||
                   _dev.IsUsb)
                    if(_dev.Type == DeviceType.ATAPI)
                        sidecar.BlockMedia[0].Interface = "ATAPI";
                    else if(_dev.IsUsb)
                        sidecar.BlockMedia[0].Interface = "USB";
                    else if(_dev.IsFireWire)
                        sidecar.BlockMedia[0].Interface = "FireWire";
                    else
                        sidecar.BlockMedia[0].Interface = "SCSI";

                sidecar.BlockMedia[0].LogicalBlocks = blocks;
                sidecar.BlockMedia[0].Manufacturer  = _dev.Manufacturer;
                sidecar.BlockMedia[0].Model         = _dev.Model;

                if(!_private)
                    sidecar.BlockMedia[0].Serial = _dev.Serial;

                sidecar.BlockMedia[0].Size = blocks * blockSize;

                if(_dev.IsRemovable)
                    sidecar.BlockMedia[0].DumpHardwareArray = _resume.Tries.ToArray();

                UpdateStatus?.Invoke(Localization.Core.Writing_metadata_sidecar);

                var xmlFs = new FileStream(_outputPrefix + ".cicm.xml", FileMode.Create);

                var xmlSer = new XmlSerializer(typeof(CICMMetadataType));
                xmlSer.Serialize(xmlFs, sidecar);
                xmlFs.Close();
            }
        }

        UpdateStatus?.Invoke("");

        UpdateStatus?.
            Invoke(string.Format(Localization.Core.Took_a_total_of_0_seconds_1_processing_commands_2_checksumming_3_writing_4_closing,
                                 (end - start).TotalSeconds, totalDuration / 1000, totalChkDuration / 1000,
                                 imageWriteDuration, (closeEnd - closeStart).TotalSeconds));

        UpdateStatus?.Invoke(string.Format(Localization.Core.Average_speed_0_MiB_sec,
                                           blockSize * (double)(blocks + 1) / 1048576 / (totalDuration / 1000)));

        if(maxSpeed > 0)
            UpdateStatus?.Invoke(string.Format(Localization.Core.Fastest_speed_burst_0_MiB_sec, maxSpeed));

        if(minSpeed is > 0 and < double.MaxValue)
            UpdateStatus?.Invoke(string.Format(Localization.Core.Slowest_speed_burst_0_MiB_sec, minSpeed));

        UpdateStatus?.Invoke(string.Format(Localization.Core._0_sectors_could_not_be_read, _resume.BadBlocks.Count));
        UpdateStatus?.Invoke("");

        Statistics.AddMedia(dskType, true);
    }
}