ISCSIConsole-Fork/ISCSIConsole/CreateDiskImageForm.cs

using DiskAccessLibrary;
using ISCSIConsole.Mods;
using System;
using System.Collections.Generic;
using System.Threading;
using System.Windows.Forms;
using static DiskAccessLibrary.Mod.Consts;

namespace ISCSIConsole
{
    public partial class CreateDiskImageForm : BaseForm
    {
        private bool _isWorking;

        private FileDialog _imageFileDialog;
        private FileDialog _snapshotFileDialog;

        public DiskImage DiskImage { get; private set; }

        private bool SnapshotControlEnabled
        {
            set
            {
                SnapshotLabel.Enabled = value;
                SnapshotTextBox.Enabled = value;
                SnapshotButton.Enabled = value;
                BlockSizeUpDown.Enabled = value;
                KbLabel.Enabled = value;
                AheadLabel.Enabled = value;

                ImageSizeUpDown.Enabled = !value;
            }
        }

        private bool NoBaseImageControlEnable
        {
            set
            {
                ImageFileLabel.Enabled = !value;
                ImageFileTextBox.Enabled = !value;
                ImageFileButton.Enabled = !value;
                ImageSizeUpDown.Enabled = value;
            }
        }

        public CreateDiskImageForm()
        {
            InitializeComponent();
        }

        private void CreateDiskImageForm_Shown(object sender, EventArgs e)
        {
            FormatComboBox.DataSource = Enum.GetValues(typeof(DiskImageFormat));
        }

        private void FormatComboBox_SelectedIndexChanged(object sender, EventArgs e)
        {
            var items = new List<DiskImageType>();
            switch ((DiskImageFormat)FormatComboBox.SelectedValue)
            {
                case DiskImageFormat.BlockDifferencingDiskImage:
                    items.Add(DiskImageType.Differencing);
                    items.Add(DiskImageType.Dynamic);
                    SnapshotControlEnabled = true;

                    _imageFileDialog = new OpenFileDialog
                    {
                        CheckFileExists = true,
                        Filter = "Raw Disk Image (*.img)|*.img"
                    };

                    _snapshotFileDialog = new SaveFileDialog
                    {
                        Filter = "Block Differencing Disk Image (*.bdd)|*.bdd"
                    };
                    break;

                case DiskImageFormat.RawDiskImage:
                    items.Add(DiskImageType.Fixed);
                    SnapshotControlEnabled = false;
                    _imageFileDialog = new SaveFileDialog
                    {
                        Filter = "Raw Disk Image (*.img)|*.img"
                    };
                    break;

                case DiskImageFormat.VirtualHardDisk:
                    items.Add(DiskImageType.Dynamic);
                    items.Add(DiskImageType.Fixed);
                    SnapshotControlEnabled = false;

                    _imageFileDialog = new SaveFileDialog
                    {
                        Filter = "VirtualHardDisk File (*.vhd)|*.vhd"
                    };
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
            }

            TypeComboBox.DataSource = items;
        }

        private void TypeComboBox_SelectedIndexChanged(object sender, EventArgs e)
        {
            var format = (DiskImageFormat)FormatComboBox.SelectedValue;
            if (format == DiskImageFormat.BlockDifferencingDiskImage)
            {
                switch ((DiskImageType)TypeComboBox.SelectedValue)
                {
                    case DiskImageType.Dynamic:
                        NoBaseImageControlEnable = true;
                        break;

                    default:
                        NoBaseImageControlEnable = false;
                        break;
                }
            }
        }

        private void ImageFileButton_Click(object sender, EventArgs e)
        {
            if (_imageFileDialog.ShowDialog() == DialogResult.OK)
            {
                ImageFileTextBox.Text = _imageFileDialog.FileName;
                if ((DiskImageFormat)FormatComboBox.SelectedValue == DiskImageFormat.BlockDifferencingDiskImage)
                {
                    var length = IoUtility.GetRealFileSize(_imageFileDialog.FileName);

                    // ReSharper disable once PossibleLossOfFraction
                    ImageSizeUpDown.Value = length / MegaByte;

                    BlockSizeUpDown_SelectedItemChanged(null, null);
                }
            }
        }

        private void SnapshotButton_Click(object sender, EventArgs e)
        {
            if (_snapshotFileDialog.ShowDialog() == DialogResult.OK)
            {
                SnapshotTextBox.Text = _snapshotFileDialog.FileName;
            }
        }

        private void ImageSizeUpDown_ValueChanged(object sender, EventArgs e)
        {
            UpdateSnapshotInfo();
        }

        private void BlockSizeUpDown_SelectedItemChanged(object sender, EventArgs e)
        {
            UpdateSnapshotInfo();
        }

        private void UpdateSnapshotInfo()
        {
            var format = (DiskImageFormat)FormatComboBox.SelectedValue;
            var type = (DiskImageType)TypeComboBox.SelectedValue;

            var blockSize = int.Parse(BlockSizeUpDown.Text) * KiloByte;

            if (format == DiskImageFormat.BlockDifferencingDiskImage && type == DiskImageType.Dynamic)
            {
                AheadLabel.Text =
                    $"Init Size:{BddInfo.CalcHeaderSize((long)(ImageSizeUpDown.Value * MegaByte), blockSize, out var blocks) / KiloByte:N0} KB" +
                    $", {blocks:N0} Blocks.";
            }
            else
            {
                AheadLabel.Text =
                    $"Init Size:{BddInfo.CalcHeaderSize(ImageFileTextBox.Text, blockSize, out var blocks) / KiloByte:N0} KB" +
                    $", {blocks:N0} Blocks.";
            }
        }

        private void btnOK_Click(object sender, EventArgs e)
        {
            var format = (DiskImageFormat)FormatComboBox.SelectedValue;
            var type = (DiskImageType)TypeComboBox.SelectedValue;

            var imgPath = ImageFileTextBox.Text;
            var imgSize = (long)ImageSizeUpDown.Value * MegaByte;

            var snapshotPath = SnapshotTextBox.Text;
            var blkSize = int.Parse(BlockSizeUpDown.Text) * KiloByte;

            if ((format != DiskImageFormat.BlockDifferencingDiskImage && type != DiskImageType.Dynamic) && imgPath == string.Empty)
            {
                MessageBox.Show("Please choose image file location", "Error");
                return;
            }

            if (format == DiskImageFormat.BlockDifferencingDiskImage
                && string.IsNullOrWhiteSpace(SnapshotTextBox.Text))
            {
                MessageBox.Show("Please choose snapshot file location", "Error");
                return;
            }

            _isWorking = true;
            new Thread(delegate ()
            {
                DiskImage diskImage;

                try
                {
                    diskImage = DiskImageCreator.CreateImage(format, type, imgPath, imgSize, snapshotPath, blkSize);
                }
                catch (Exception ex)
                {
                    Invoke((MethodInvoker)delegate
                    {
                        MessageBox.Show("Failed to create the disk: " + ex.Message, "Error");
                        ImageFileTextBox.Enabled = true;
                        ImageFileButton.Enabled = true;
                        ImageSizeUpDown.Enabled = true;
                        btnOK.Enabled = true;
                        btnCancel.Enabled = true;
                    });
                    _isWorking = false;
                    return;
                }

                var isLocked = diskImage.ExclusiveLock();
                if (!isLocked)
                {
                    Invoke((MethodInvoker)delegate
                    {
                        MessageBox.Show("Cannot lock the disk image for exclusive access", "Error");
                        ImageFileTextBox.Enabled = true;
                        ImageFileButton.Enabled = true;
                        ImageSizeUpDown.Enabled = true;
                        btnOK.Enabled = true;
                        btnCancel.Enabled = true;
                        _isWorking = false;
                    });
                    return;
                }
                DiskImage = diskImage;
                Invoke((MethodInvoker)delegate
                {
                    _isWorking = false;
                    DialogResult = DialogResult.OK;
                    Close();
                });
            }).Start();

            ImageFileTextBox.Enabled = false;
            ImageFileButton.Enabled = false;
            ImageSizeUpDown.Enabled = false;
            btnOK.Enabled = false;
            btnCancel.Enabled = false;
        }

        private void btnCancel_Click(object sender, EventArgs e)
        {
            DialogResult = DialogResult.Cancel;
            Close();
        }

        private void CreateDiskImageForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (_isWorking)
            {
                e.Cancel = true;
                MessageBox.Show("Please wait until the creation of the disk image is completed.", "Error");
            }
        }

        private void PhysicalDiskButton_Click(object sender, EventArgs e)
        {
        }
    }
}