/// Copyright (c) 2021 Iiro Iivanainen, Harri Linna, Jere Pakkanen, Riikka Vilavaara
/// 
/// Permission is hereby granted, free of charge, to any person obtaining
/// a copy of this software and associated documentation files (the
/// "Software"), to deal in the Software without restriction, including
/// without limitation the rights to use, copy, modify, merge, publish,
/// distribute, sublicense, and/or sell copies of the Software, and to
/// permit persons to whom the Software is furnished to do so, subject to
/// the following conditions:
/// 
/// The above copyright notice and this permission notice shall be included
/// in all copies or substantial portions of the Software.
/// 
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
/// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
/// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
/// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
/// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
/// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
/// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
/// 

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using ImageMagick;

namespace CoreLibrary
{
    /// <summary>
    /// Exception class for image reading
    /// </summary>
    public class ImageReadException : Exception
    {
        public ImageReadException(string message) : base(message)
        {
        }
    }

    /// <summary>
    /// Exception class for stack writing
    /// </summary>
    public class StackWriteException : Exception
    {
        public StackWriteException(string message) : base(message)
        {
        }
    }

    /// <summary>
    /// Exception class for stack deleting
    /// </summary>
    public class StackDeleteException : Exception
    {
        public StackDeleteException(string message) : base(message)
        {
        }
    }

    /// <summary>
    /// Class for reading and writing 3D-map files.
    /// </summary>
    public class MapReader
    {
        #region image sequnce
        /// <summary>
        /// Makes a guess what image sequence template name could be from the
        /// file name.
        /// </summary>
        /// <param name="filepath">Filepath of some picture of the image sequence
        /// stack.</param>
        /// <returns>Guess for the image sequence filename template.</returns>
        /// <exception cref="ArgumentException">Thrown when failed to guess template name</exception>
        /// <exception cref="IOException">Thrown when failed to do IO operations to the image 
        /// sequence file</exception>
        public static string MakeImgSeqTemplateGuess(string filepath)
        {
            if (!File.Exists(filepath)) return "";
            FileAttributes attr = File.GetAttributes(filepath);
            if ((attr & FileAttributes.Directory) == FileAttributes.Directory)
                return "";
            int filetypeI = filepath.LastIndexOf(".");
            int filepathI = filepath.LastIndexOf("\\");
            string filename
                = filepath.Substring(filepathI + 1, filetypeI - filepathI - 1);
            char[] digits
                = new[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
            string template = filename.TrimEnd(digits);
            return template;
        }

        /// <summary>
        /// Changes filepath to integer according to the ending of filename. 
        /// Works as a natural sort for LINQ OrderBy aslong as the filename 
        /// stays the same.
        /// </summary>
        /// <param name="filepath">String of filepath.</param>
        /// <returns>The integer in the end of the file, or 0 if there isnt any.</returns>
        /// <exception cref="ArgumentException">Thrown when failed to sort filenames</exception>
        private static int NaturalSort(string filepath)
        {
            int filetypeI = filepath.LastIndexOf(".");
            int filepathI = filepath.LastIndexOf("\\");
            string path 
                = filepath.Substring(filepathI + 1, filetypeI - filepathI - 1);
            if(Int32.TryParse(string.Concat(path.ToArray().Reverse().TakeWhile(char.IsNumber).Reverse()),
                                                                   out int result)) return result;
            return 1;
        }

        /// <summary>
        /// Makes a filelist for image sequence.
        /// </summary>
        /// <param name="filepath">Path to the image sequence file or directory
        /// containing it.</param>
        /// <param name="template">Template to filter image files.</param>
        /// <returns>List of paths containing image sequence.</returns>
        /// <exception cref="ImageReadException">Thrown when failed to make image list</exception>
        private static List<string> MakeImgSeqFileList(string filepath,
                                                         string template)
        {
            try
            {
                int filepathI = filepath.LastIndexOf("\\");
                string path = filepath.Substring(0, filepathI);

                string[] files = Directory.GetFiles(path);
                List<string> filteredFiles = new();

                //Filter non-image files.
                string[] imgExtensions = { "png", "bmp", "tif", "tiff" };
                foreach (string file in files)
                {
                    string filename = file[(file.LastIndexOf("\\") + 1)..];
                    if (imgExtensions.Any(x => file.EndsWith(x))
                         && filename.StartsWith(template))
                        filteredFiles.Add(file);
                }
                return filteredFiles.OrderBy(file => NaturalSort(file)).ToList();
            }
            catch(ArgumentException e)
            {
                throw new ImageReadException("Failed to sort the files: " + e.Message);
            }
        }

        /// <summary>
        /// Reads a 2D image from image sequence.
        /// </summary>
        /// <param name="filepath">Location of the stack files.</param>
        /// <param name="depth">The depth of the 2D slice.</param>
        /// <returns>A MagickImage object from the read file.</returns>
        /// <exception cref="ImageReadException">Thrown when failed to read image</exception>
        public static MagickImage ReadImgSeq(string filepath, int depth,
                                                            string template)
        {
            try
            {
                if (depth < 0) depth = 0;
                if (!filepath.Contains("\\")) throw
                        new ImageReadException("Invalid filepath");
                int filepathI = filepath.LastIndexOf("\\");
                string path = filepath.Substring(0, filepathI);
                if (!Directory.Exists(path)) throw
                        new ImageReadException("Directory does not exist");

                List<string> filteredFiles = MakeImgSeqFileList(filepath, template);
                if (depth >= filteredFiles.Count) throw
                        new ImageReadException("Image out of bounds");
                string loadImg = filteredFiles[depth];

                MagickImage image = new();
                if (File.Exists(loadImg))
                {
                    image.Read(loadImg);
                    image.Density = new Density(96);
                    return image;
                }
                throw new ImageReadException("Image does not exist");
            }
            catch (MagickException e)
            {
                throw new ImageReadException("Failed to read sequence file: " 
                                                + e.Message);
            }
            catch (ArgumentException e)
            {
                throw new ImageReadException("Failed to read sequence file: "
                                                + e.Message);
            }

        }

        /// <summary>
        /// Gets the stack size of image sequence.
        /// </summary>
        /// <param name="filepath">Path file to the sequence.</param>
        /// <param name="template">Template for filtering.</param>
        /// <returns>How many slices there are.</returns>
        public static int SequenceSlices(string filepath, string template)
        {
            try
            {
                if (!filepath.Contains("\\")) return 0;
                int filepathI = filepath.LastIndexOf("\\");
                string path = filepath.Substring(0, filepathI);

                if (!Directory.Exists(path)) return 0;

                string[] files = Directory.GetFiles(path);
                List<string> filteredFiles = new();

                //Filter non-image files.
                string[] imgExtensions = { "png", "bmp", "tif", "tiff" };
                foreach (string file in files)
                {
                    string filename = file[(file.LastIndexOf("\\") + 1)..];
                    if (imgExtensions.Any(x => file.EndsWith(x))
                        && filename.StartsWith(template)) filteredFiles.Add(file);
                }

                return filteredFiles.Count;
            }
            catch (IOException)
            {
                return 0;
            }
            catch (ArgumentException)
            {
                return 0;
            }
            catch (UnauthorizedAccessException)
            {
                return 0;
            }
        }

        /// <summary>
        /// Makes a new stack from the original stack that is Y-axel oriented
        /// and writes it to harddrive.
        /// </summary>
        /// <param name="filepath">Path to the original stack.</param>
        /// <param name="template">Template to filter files from the folder.</param>
        /// <param name="destinationPath">Where the program writes the stack.</param>
        /// <param name="yStackName">Template name for the written image files.</param>
        /// <exception cref="StackWriteException">Thrown when failed to write stack</exception>
        public static void MakeSeqYStack(string filepath, string template,
                                     string destinationPath, string yStackName)
        {
            try {
                int filepathI = filepath.LastIndexOf("\\");
                string path = filepath.Substring(0, filepathI);

                List<string> filteredFiles = MakeImgSeqFileList(filepath, template);

                //Initialize empty destination filepath and y stack name
                if (destinationPath == "")
                {
                    destinationPath = path + "\\yStack\\";
                    if (!Directory.Exists(destinationPath))
                        Directory.CreateDirectory(destinationPath);
                }
                string imgExtension
                    = filteredFiles[0][filteredFiles[0].LastIndexOf(".")..];
                if (yStackName == "")
                {
                    yStackName
                        = filteredFiles[0].Substring(filteredFiles[0].LastIndexOf("\\")
                        + 1, filteredFiles[0].LastIndexOf(".")
                        - filteredFiles[0].LastIndexOf("\\") - 1) + "y";

                    char[] digits
                        = new[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
                    yStackName = yStackName.TrimEnd(digits);
                }

                for (int i = 0; i < filteredFiles.Count; i++)
                {
                    using MagickImage slice = new();
                    slice.Read(filteredFiles[i]);
                    for (int j = 0; j < slice.Height; j++)
                    {
                        if (i == 0 && File.Exists(destinationPath + "\\" + yStackName + j + imgExtension))
                            File.Delete(destinationPath + "\\" + yStackName + j + imgExtension);
                        using MagickImageCollection stack = new();
                        MagickReadSettings ySettings = new();
                        ySettings.Width = slice.Width;
                        ySettings.Height = 1;
                        MagickImage ySlice = new("xc:black", ySettings);
                        ySlice.Format = slice.Format;
                        ySlice.Grayscale();
                        ySlice.CopyPixels(slice, new MagickGeometry(0, j, slice.Width, 1));
                        if (File.Exists(destinationPath + "\\" + yStackName + j + imgExtension))
                            stack.Add(destinationPath + "\\" + yStackName + j + imgExtension);
                        stack.Add(ySlice);
                        stack.AppendVertically().Write(destinationPath + "\\" + yStackName + j + imgExtension);
                    }
                }
            }
            catch (IOException e)
            {
                throw new StackWriteException("Failed to write image sequence files, problems with IO operations: " 
                                                + e.Message);
            }
            catch (MagickException e)
            {
                throw new StackWriteException("Failed to write image sequence files. Problems with Magick.NET: " 
                                                + e.Message);
            }
            catch (ArgumentException e)
            {
                throw new StackWriteException("Failed to write image sequence files: " + e.Message);
            }
        }

        /// <summary>
        /// Makes a new stack from the original stack that is X-axel oriented and
        /// writes it to harddrive.
        /// </summary>
        /// <param name="filepath">Path to the original stack.</param>
        /// <param name="template">Template to filter files from the folder.</param>
        /// <param name="destinationPath">Where the program writes the stack.</param>
        /// <param name="xStackName">Template name for the written image files.</param>
        /// <exception cref="StackWriteException">Thrown when failed to write stack </exception>
        public static void MakeSeqXStack(string filepath, string template,
            string destinationPath, string xStackName)
        {
            try
            {
                int filepathI = filepath.LastIndexOf("\\");
                string path = filepath.Substring(0, filepathI);

                List<string> filteredFiles = MakeImgSeqFileList(filepath, template);

                //Initialize empty destination filepath and x stack name.
                if (destinationPath == "")
                {
                    destinationPath = path + "\\xStack\\";
                    if (!Directory.Exists(destinationPath))
                        Directory.CreateDirectory(destinationPath);
                }
                string imgExtension
                    = filteredFiles[0][filteredFiles[0].LastIndexOf(".")..];
                if (xStackName == "")
                {
                    xStackName
                        = filteredFiles[0].Substring(filteredFiles[0].LastIndexOf("\\") + 1,
                                                     filteredFiles[0].LastIndexOf(".")
                                                      - filteredFiles[0].LastIndexOf("\\") - 1) + "x";

                    char[] digits
                        = new[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
                    xStackName = xStackName.TrimEnd(digits);
                }

                for (int i = 0; i < filteredFiles.Count; i++)
                {
                    using MagickImage slice = new();
                    slice.Read(filteredFiles[i]);
                    for (int j = 0; j < slice.Width; j++)
                    {
                        if (i == 0 && File.Exists(destinationPath + "\\" + xStackName + j + imgExtension))
                            File.Delete(destinationPath + "\\" + xStackName + j + imgExtension);
                        using MagickImageCollection stack
                            = new();
                        MagickReadSettings xSettings = new();
                        xSettings.Width = 1;
                        xSettings.Height = slice.Height;
                        MagickImage xSlice = new("xc:black", xSettings);
                        xSlice.Format = slice.Format;
                        xSlice.Grayscale();
                        xSlice.CopyPixels(slice,
                                     new MagickGeometry(j, 0, 1, slice.Height));
                        if (File.Exists(destinationPath + "\\" + xStackName + j + imgExtension))
                            stack.Add(destinationPath + "\\" + xStackName + j + imgExtension);
                        stack.Add(xSlice);
                        stack.AppendHorizontally().Write(destinationPath + "\\" + xStackName + j + imgExtension);
                    }
                }
            }
            catch (IOException e)
            {
                throw new StackWriteException("Failed to write image sequence files, problems with IO operations: "
                                                + e.Message);
            }
            catch (MagickException e)
            {
                throw new StackWriteException("Failed to write image sequence files. Problems with Magick.NET: "
                                                + e.Message);
            }
            catch (ArgumentException e)
            {
                throw new StackWriteException("Failed to write image sequence files: " + e.Message);
            }
        }
        #endregion

        #region 3D-tif
        /// <summary>
        /// Reads a 2D image from 3D tif file.
        /// </summary>
        /// <param name="filepath">Filepath of the image.</param>
        /// <param name="depth">The depth of the 2D slice.</param>
        /// <returns>A MagickImage object from the read file.</returns>
        /// <exception cref="ImageReadException">Thrown when failed to read image</exception>
        public static MagickImage Read3Dtif(string filepath, int depth)
        {
            
            if (!File.Exists(filepath)) throw new ImageReadException("Image does not exist");
            try
            {
                MagickImageCollection images = new();
                MagickImageCollection meta = new();
                meta.Ping(filepath);
                if (depth < meta.Count && depth >= 0)
                {
                    MagickReadSettings settings = new();
                    settings.FrameIndex = depth;
                    settings.FrameCount = 1;

                    images.Read(filepath, settings);
                    MagickImage image = (MagickImage)images[0];
                    image.Density = new Density(96);
                    return image;
                }
                else throw new ImageReadException("Image out of bounds");
            }
            catch(MagickException e)
            {
                throw new ImageReadException("Error reading image: " + e.Message);
            }
        }

        /// <summary>
        /// Gets the stack size of 3D tif stack.
        /// </summary>
        /// <param name="filepath">Location of the file.</param>
        /// <returns>Size of the 3D tif stack.</returns>
        public static int ThreeDTifSlices(string filepath)
        {
            try
            {
                if (!File.Exists(filepath)) return 0;
                MagickImageCollection images = new();
                images.Ping(filepath);
                return images.Count;
            }
            catch (MagickException)
            {
                return 0;
            }
            
        }
        #endregion

        #region raw
        /// <summary>
        /// Turns one color channel raw data to image magick object.
        /// </summary>
        /// <param name="filepath"> Location of the raw data file.</param>
        /// <param name="depth">What depth we take the slice.</param>
        /// <param name="width">Width of the picture.</param>
        /// <param name="height">Height of the picture<./param>
        /// <param name="byteDepth">How many bytes represents one pixel.</param>
        /// <param name="littleEndian">Is the raw data in little endian form.</param>
        /// <returns>MagickImage object in png format containing the picture
        /// from the raw data.</returns>
        /// <exception cref="ImageReadException">Thrown when failed to read image</exception>
        public static MagickImage ReadRaw(string filepath, int depth, int width,
                                 int height, int byteDepth, bool littleEndian)
        {
            try
            {
                if (!File.Exists(filepath)) throw new ImageReadException("File does not exist");
                if (depth > RawSlices(filepath, width, height, byteDepth))
                    throw new ImageReadException("Tried to read image out of bounds");
                if (width < 1 || height < 1) throw new ImageReadException("Tried to read image out of bounds");
                if (depth < 0) depth = 0;
                MagickImage image = new();
                var pixelDepth = byteDepth switch
                {
                    2 => StorageType.Short,
                    4 => StorageType.Float,
                    8 => StorageType.Double,
                    _ => StorageType.Char,
                };
                FileStream fs = new(filepath, FileMode.Open, FileAccess.Read);
                int sliceSize = byteDepth * width * height;
                long offSet = (long)sliceSize * (long)depth;
                byte[] bytes = new byte[sliceSize];
                fs.Seek(offSet, SeekOrigin.Begin);
                fs.Read(bytes, 0, sliceSize);
                fs.Close();
                if (!littleEndian)
                {
                    for (int i = 0; i < bytes.Length; i += byteDepth)
                    {
                        byte[] temp = new byte[byteDepth];
                        for (int j = 0; j < temp.Length; j++)
                        {
                            temp[temp.Length - j - 1] = bytes[i + j];
                        }
                        for (int j = 0; j < temp.Length; j++)
                        {
                            bytes[i + j] = temp[j];
                        }
                    }
                }
                PixelReadSettings pixelSettings = new(width, height,
                    pixelDepth, "R");
                image.ReadPixels(bytes, pixelSettings);
                image.Format = MagickFormat.Tif;
                image.Density = new Density(96);
                return image;
            }
            catch (IOException e)
            {
                throw new ImageReadException("Failed to read raw file, problems with IO operations: " 
                                                + e.Message);
            }
            catch (MagickException e)
            {
                throw new ImageReadException("Failed to read raw file, Magick.NET exception: " 
                                                + e.Message);
            }
            catch (ArgumentException e)
            {
                throw new ImageReadException("Failed to read raw file: "
                                                + e.Message);
            }

        }

        /// <summary>
        /// Gets the stack size of raw data image stack.
        /// </summary>
        /// <param name="filepath">Location of the file.</param>
        /// <param name="width">Width of one image in the stack.</param>
        /// <param name="height">Heigth of one image in the stack.</param>
        /// <param name="byteDepth">How many bytes represents one pixel</param>
        /// <returns>Size of the raw stack.</returns>
        public static int RawSlices(string filepath, int width, int height,
                                                                 int byteDepth)
        {
            try
            {
                if (!File.Exists(filepath)) return 0;
                long slices
                    = new System.IO.FileInfo(filepath).Length / (width * height * byteDepth);
                return (int)slices;
            }
            catch (IOException)
            {
                return 0;
            }
            
        }

        /// <summary>
        /// Makes a new stack from the original raw stack that is Y-axel
        /// oriented and writes it to harddrive.
        /// </summary>
        /// <param name="filepath">Path to original stack.</param>
        /// <param name="destinationPath">Path to new stack, if "" will
        /// be put in a new folder in the same filepath as the original stack.</param>
        /// <param name="yStackName">Name of the new stack file, if "" will
        /// be the same name as original + y.</param>
        /// <param name="heigth">Heigth of the raw file.</param>
        /// <param name="width">Width of the raw file.</param>
        /// <param name="z">Depth of the stack.</param>
        /// <param name="byteDepth">How many bytes represents 1 pixel.</param>
        /// <exception cref="StackWriteException">Thrown when failed to write stack</exception>
        public static void MakeRawYStack(string filepath, string destinationPath,
              string yStackName, int heigth, int width, int z, int byteDepth)
        {
            try
            {
                int filepathI = filepath.LastIndexOf("\\");
                string path = filepath.Substring(0, filepathI);

                //Initialize empty destination filepath and x stack name.
                if (destinationPath == "")
                {
                    destinationPath = path + "\\yStack\\";
                    if (!Directory.Exists(destinationPath))
                        Directory.CreateDirectory(destinationPath);
                }
                if (yStackName == "")
                {
                    yStackName
                        = filepath.Substring(filepath.LastIndexOf("\\") + 1,
                                             filepath.LastIndexOf(".")
                                                - filepath.LastIndexOf("\\") - 1) + "y" + "raw";
                }
                int row = width * byteDepth;
                long sliceSizeDest = (long)width * (long)z * (long)byteDepth;
                long sliceSizeOrig = (long)heigth * (long)row;
                if (File.Exists(destinationPath + "\\" + yStackName))
                {
                    File.Delete(destinationPath + "\\" + yStackName);
                }
                using (FileStream fs
                   = new(destinationPath + "\\" + yStackName,
                                     FileMode.CreateNew))
                {
                    try
                    {
                        fs.Seek(sliceSizeOrig * (long)z - 1, SeekOrigin.Begin);
                        fs.WriteByte(0);
                    }
                    catch (IOException)
                    {
                        throw;
                    }
                    finally
                    {
                        fs.Close();
                    }
                }
                using FileStream rs = File.OpenRead(filepath);
                using FileStream ws
                    = new(destinationPath + "\\" + yStackName,
                                     FileMode.Open);
                try
                {
                    ws.Position = 0;
                    rs.Position = 0;
                    byte[] bytes = new byte[row];
                    for (int i = 0; i < z; i++)
                    {
                        for (int j = 0; j < heigth; j++)
                        {
                            ws.Position
                                = sliceSizeDest * (long)j + (long)i * (long)row;
                            rs.Read(bytes, 0, row);
                            ws.Write(bytes, 0, row);
                        }
                    }
                }
                catch (IOException)
                {
                    throw;
                }
                catch (ArgumentException)
                {
                    throw;
                }
                finally
                {
                    ws.Close();
                    rs.Close();
                }
            }
            catch (IOException e)
            {
                throw new StackWriteException("Failed to write raw stack to file, problems with IO operations: " 
                                                + e.Message);
            }
            catch (ArgumentException e)
            {
                throw new StackWriteException("Failed to write raw stack to file, bad parameters: " 
                                                + e.Message);
            }
        }

        /// <summary>
        /// Makes a new stack from the original raw stack that is Y-axel oriented
        /// and writes it to harddrive.
        /// </summary>
        /// <param name="filepath">Path to original stack.</param>
        /// <param name="destinationPath">Path to new stack, if "" will be put
        /// in a new folder in the same filepath as the original stack.</param>
        /// <param name="xStackName">Name of the new stack file, if "" will be
        /// the same name as original + y.</param>
        /// <param name="heigth">Heigth of the raw file.</param>
        /// <param name="width">Width of the raw file.</param>
        /// <param name="z">Depth of the stack.</param>
        /// <param name="byteDepth">How many bytes represents 1 pixel.</param>
        /// <exception cref="StackWriteException">Thrown when failed to write stack</exception>
        public static void MakeRawXStack(string filepath, string destinationPath,
            string xStackName, int heigth, int width, int z, int byteDepth)
        {
            try
            {
                int filepathI = filepath.LastIndexOf("\\");
                string path = filepath.Substring(0, filepathI);

                //Initialize empty destination filepath and x stack name.
                if (destinationPath == "")
                {
                    destinationPath = path + "\\xStack\\";
                    if (!Directory.Exists(destinationPath))
                        Directory.CreateDirectory(destinationPath);
                }
                if (xStackName == "")
                {
                    xStackName = filepath.Substring(filepath.LastIndexOf("\\") + 1,
                        filepath.LastIndexOf(".") - filepath.LastIndexOf("\\") - 1) + "x" + ".raw";
                }
                int rowDest = z * byteDepth;
                long sliceSizeDest = (long)heigth * (long)z * (long)byteDepth;
                long sliceSizeOrig = (long)heigth * (long)width * (long)byteDepth;
                if (File.Exists(destinationPath + "\\" + xStackName)) {
                    File.Delete(destinationPath + "\\" + xStackName);
                }
                using (FileStream fs
                    = new(destinationPath + "\\" + xStackName, FileMode.CreateNew))
                {
                    try
                    {
                        fs.Seek(sliceSizeOrig * (long)z - 1, SeekOrigin.Begin);
                        fs.WriteByte(0);
                        
                    }
                    catch(IOException)
                    {
                        throw;
                    }
                    finally
                    {
                        fs.Close();
                    }
                }
                using FileStream rs = File.OpenRead(filepath);
                using FileStream ws
                    = new(destinationPath + "\\" + xStackName,
                                     FileMode.Open);
                try
                {
                    ws.Position = 0;
                    rs.Position = 0;
                    byte[] bytes = new byte[byteDepth];
                    for (int i = 0; i < z; i++)
                    {
                        for (int j = 0; j < heigth; j++)
                        {
                            for (int k = 0; k < width; k++)
                            {
                                ws.Position
                                    = ((long)width - (long)k - 1) * sliceSizeDest
                                    + (long)j * (long)rowDest
                                    + i * (long)byteDepth;
                                rs.Read(bytes, 0, byteDepth);
                                ws.Write(bytes, 0, byteDepth);
                            }
                        }
                    }
                }
                catch(IOException)
                {
                    throw;
                }
                catch(ArgumentException)
                {
                    throw;
                }
                finally
                {
                    ws.Close();
                    rs.Close();
                }
            }
            catch (IOException e)
            {
                throw new StackWriteException("Failed to write raw stack to file, problems wit IO operations: "
                                                + e.Message);
            }
            catch(ArgumentException e)
            {
                throw new StackWriteException("Failed to write raw stack to file, bad parameters: " 
                                                + e.Message);
            }
        }
        #endregion

        /// <summary>
        /// Delete written stacks from harddrive.
        /// </summary>
        /// <param name="filepath">Filepath to the deleted file.</param>
        /// <param name="template">Template for stack written in multiple files.</param>
        /// <param name="multifile">Is the stack in multiple files.</param>
        /// <exception cref="StackDeleteException">Thrown when failed to delete stack</exception>
        public static void DeleteStack(string filepath, string template, bool multifile)
        {
            try
            {
                if (multifile)
                {
                    List<string> filteredFiles = MakeImgSeqFileList(filepath, template);
                    foreach (string file in filteredFiles)
                    {
                        File.Delete(file);
                    }
                }
                else if (File.Exists(filepath)) File.Delete(filepath);
            }
            catch (IOException e)
            {
                throw new StackDeleteException("Failed to delete files. Problems with IO operations: " 
                                                + e.Message);
            }
            catch (ArgumentException e)
            {
                throw new StackDeleteException("Failed to delete files: "
                                                + e.Message);
            }
        }
    }
}