/// 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.Collections.Generic;
using System.IO;
using System.Text.Json.Serialization;

namespace CoreLibrary
{
    /// <summary>
    /// Sample class that contains map, attached datas and meta data that is connected to sample.
    /// Is responsible for interaction between map data and attached data. Is also the only class 
    /// that directly interacts with GUI.
    /// </summary>
    public class Sample
    {
        public string Name { get; set; }
        [JsonIgnore]
        public string Filepath { get; set; }
        public Map Map { get; set; }
        public Attachments AttDataList { get; set; }
        public Metas MetaList { get; set; }


        /// <summary>
        /// Constructor for JSON serialization and deserialization. Note that the 
        /// parameter names must match the attribute names (non case sensitive)
        /// </summary>
        /// <param name="name">Name of the file</param>
        /// <param name="map">Map containing all stacks</param>
        /// <param name="attdatalist">List of attached datas</param>
        /// <param name="metalist">List of sample metadata</param>
        [JsonConstructor]
        public Sample(string name, Map map, Attachments attdatalist, Metas metalist)
        {
            Name = name;
            Map = map;
            AttDataList = attdatalist;
            MetaList = metalist;
        }
        

        /// <summary>
        /// Getting Slice X as byte array.
        /// </summary>
        /// <returns>Slice X as byte array</returns>
        public byte[] GetSliceX()
        {
            return Map.StackX.GetAsByteArray();
        }


        /// <summary>
        /// Getting Slice Y as byte array.
        /// </summary>
        /// <returns>Slice Y as byte array</returns>
        public byte[] GetSliceY()
        {
            return Map.StackY.GetAsByteArray();
        }


        /// <summary>
        /// Getting Slice Z as byte array.
        /// </summary>
        /// <returns>Slice Z as byte array</returns>
        public byte[] GetSliceZ()
        {
            return Map.StackZ.GetAsByteArray();
        }


        /// <summary>
        /// Updating stack Z when depth changes
        /// </summary>
        /// <param name="depth">Depth of slice</param>
        public void UpdateStackZ(int depth)
        {
            Map.UpdateStackZ(depth);
        }


        /// <summary>
        /// Updating stack X when depth changes
        /// </summary>
        /// <param name="depth">Depth of slice</param>
        public void UpdateStackX(int depth)
        {
            Map.UpdateStackX(depth);
        }


        /// <summary>
        /// Updating stack Y when depth changes
        /// </summary>
        /// <param name="depth">Depth of slice</param>
        public void UpdateStackY(int depth)
        {
            Map.UpdateStackY(depth);
        }


        /// <summary>
        /// Setting Filepath for Stack Z.
        /// </summary>
        /// <param name="path">File path for Stack Z</param>
        public void SetFilepathZ(string path)
        {
            Map.StackZ.SetFilepath(path);
        }

        
        /// <summary>
        /// Get file path for stack Z.
        /// </summary>
        /// <returns>Stack Z filepath.</returns>
        public string GetFilepathZ()
        {
            return Map.StackZ.GetFilepath();
        }


        /// <summary>
        /// Setting Filepath for Stack X
        /// </summary>
        /// <param name="path">File path for Stack X</param>
        public void SetFilepathX(string path)
        {
            Map.StackX.SetFilepath(path);
        }


        /// <summary>
        /// Get file path for stack X.
        /// </summary>
        /// <returns>Stack X filepath.</returns>
        public string GetFilepathX()
        {
            return Map.StackX.GetFilepath();
        }


        /// <summary>
        /// Setting Filepath for Stack Y
        /// </summary>
        /// <param name="path">File path for Stack Y</param>
        public void SetFilepathY(string path)
        {
            Map.StackY.SetFilepath(path);
        }


        /// <summary>
        /// Get file path for stack Y.
        /// </summary>
        /// <returns>Stack Y filepath.</returns>
        public string GetFilepathY()
        {
            return Map.StackY.GetFilepath();
        }


        /// <summary>
        /// Setting template for Z stack. Only used for Image Sequence.
        /// </summary>
        /// <param name="template">Template</param>
        public void SetMapTemplateZ(string template)
        {
            Map.StackZ.Template = template;
        }


        /// <summary>
        /// Setting template for X stack. Only used for Image Sequence.
        /// </summary>
        /// <param name="template">Template</param>
        public void SetMapTemplateX(string template)
        {
            Map.StackX.Template = template;
        }


        /// <summary>
        /// Setting template for Y stack. Only used for Image Sequence.
        /// </summary>
        /// <param name="template">Template</param>
        public void SetMapTemplateY(string template)
        {
            Map.StackY.Template = template;
        }

        /// <summary>
        /// Sets sample relations according to the given filepath
        /// </summary>
        /// <param name="relativeTo">Filepath that all others are 
        /// relative to</param>
        public void SetSampleRelations(string relativeTo)
        {
            Map.SetMapRelation(relativeTo);
            AttDataList.SetAttachmentRelation(relativeTo);
        }


        /// <summary>
        /// Gets the Mark amount from specified dimension
        /// 1 = X depth, 2 = Y depth, 3 = Z depth
        /// TODO: use enum instead of an integer?
        /// </summary>
        /// <param name="depth"> </param>
        /// <returns></returns>
        public int[] GetMarkCount(int depth)
        {
            int[] markCount = System.Array.Empty<int>();

            switch (depth)
            {
                case 0:
                    markCount = new int[Map.SlicesX];
                    break;
                case 1:
                    markCount = new int[Map.SlicesY];
                    break;
                case 2:
                    markCount = new int[Map.SlicesZ];
                    break;
                default:
                    break;
            }


            if (markCount.Length == 0) return markCount;

            int[][] markCountAll = AttDataList.AttachementCount(Map.SlicesX, Map.SlicesY, Map.SlicesZ);


            for (int i = 0; i < markCount.Length; i++)    
            {
                markCount[i] = markCountAll[depth][i];
            }
            return markCount;
        }


        /// <summary>
        /// Setting the depth of Z.
        /// </summary>
        /// <param name="path">File path</param>
        public void SetSlicesZ(string path)
        {
            switch (Map.MapType)
            {
                case Map.FileType.ImageSequence:
                    Map.SlicesZ = MapReader.SequenceSlices(path, Map.StackZ.Template);
                    break;
                case Map.FileType.Tiff3D:
                    Map.SlicesZ = MapReader.ThreeDTifSlices(path);
                    break;
                case Map.FileType.Raw:
                    Map.SlicesZ = MapReader.RawSlices(path, Map.SlicesX, Map.SlicesY, Map.ByteDepth);
                    break;
                default:
                    break;
            }
        }


        /// <summary>
        /// Sets the Map file type as image sequence.
        /// </summary>
        public void SetImageSequence()
        {
            Map.MapType = Map.FileType.ImageSequence;
        }


        /// <summary>
        /// Sets the Map file type as multiframe tiff.
        /// </summary>
        public void SetTiff3D()
        {
            Map.MapType = Map.FileType.Tiff3D;
        }


        /// <summary>
        /// Sets the Map file type as Raw.
        /// </summary>
        public void SetRaw()
        {
            Map.MapType = Map.FileType.Raw;
        }


        /// <summary>
        /// Sets byte depth for Map. Used for Raw files.
        /// </summary>
        /// <param name="byteDepth">Byte depth.</param>
        public void SetByteDepth(int byteDepth)
        {
            Map.ByteDepth = byteDepth;
        }


        /// <summary>
        /// Sets width of Map.
        /// </summary>
        /// <param name="mapWidth">Width of Map.</param>
        public void SetMapWidth(int mapWidth)
        {
            Map.SlicesX = mapWidth;
        }


        /// <summary>
        /// Sets height for Map.
        /// </summary>
        /// <param name="mapHeight">Height of Map.</param>
        public void SetMapHeight(int mapHeight)
        {
            Map.SlicesY = mapHeight;
        }


        /// <summary>
        /// Sets how many images the Map has in Z-axis.
        /// </summary>
        /// <param name="mapDepth">Number of images.</param>
        public void SetMapDepth(int mapDepth)
        {
            Map.SlicesZ = mapDepth;
        }


        /// <summary>
        /// Sets little endian for Map. Used for Raw files.
        /// </summary>
        /// <param name="littleEndian">True if little endian, false if big endian.</param>
        public void SetLittleEndian(bool littleEndian)
        {
            Map.LittleEndian = littleEndian;
        }


        /// <summary>
        /// Returns Attached Data list.
        /// </summary>
        /// <returns>Returns all attached datas</returns>
        public Attachments GetAttachements()
        {
            return AttDataList;
        }


        /// <summary>
        /// New Sample object.
        /// </summary>
        public Sample()
        {
            Map = new();
            MetaList = new();
            AttDataList = new();
        }


        /// <summary>
        /// Search attachments that have specific Z coordinate.
        /// </summary>
        /// <param name="z">Z coordinate.</param>
        /// <returns>List of Attachments.</returns>
        public List<AttachedData> AttachmentsByZCoordinate(int z)
        {
            return AttDataList.AttByZCoordinate(z);
        }


        /// <summary>
        /// Search attachments that have specific X coordinate.
        /// </summary>
        /// <param name="x">X coordinate.</param>
        /// <returns>List of Attachments.</returns>
        public List<AttachedData> AttachmentsByXCoordinate(int x)
        {
            return AttDataList.AttByXCoordinate(x);
        }


        /// <summary>
        /// Search attachments that have specific Y coordinate.
        /// </summary>
        /// <param name="y">Y coordinate.</param>
        /// <returns>List of Attachments.</returns>
        public List<AttachedData> AttachmentsByYCoordinate(int y)
        {
            return AttDataList.AttByYCoordinate(y);
        }


        /// <summary>
        /// Search Attachment by name.
        /// </summary>
        /// <param name="name">Searched name.</param>
        /// <returns>Attachment with specified name.</returns>
        public AttachedData GetAttachment(string name)
        {
            return AttDataList.GetAttachment(name);
        }



        /// <summary>
        /// Get Map's file type.
        /// </summary>
        /// <returns>File type extension of Map's file name.</returns>
        public string GetMapFileType()
        {
            return Map.GetMapFileType();
        }


        /// <summary>
        /// Get Map's bit depth.
        /// </summary>
        /// <returns>Bit depth of map.</returns>
        public int GetBitDepth()
        {
            return Map.GetBitDepth();
        }


        /// <summary>
        /// Get sample's filepath.
        /// </summary>
        /// <returns>Sample's filepath.</returns>
        public string GetFilepath()
        {
            return Filepath;
        }


        /// <summary>
        /// Adjust Level of Stack Z.
        /// </summary>
        /// <param name="blackPoint">Black point in percentage.</param>
        /// <param name="whitePoint">White point in percentage.</param>
        public void AdjustLevelZ(double blackPoint, double whitePoint)
        {
            Map.StackZ.AdjustLevel(blackPoint, whitePoint);
        }


        /// <summary>
        /// Adjust Level of Stack X.
        /// </summary>
        /// <param name="blackPoint">Black point in percentage.</param>
        /// <param name="whitePoint">White point in percentage.</param>
        public void AdjustLevelX(double blackPoint, double whitePoint)
        {
            Map.StackX.AdjustLevel(blackPoint, whitePoint);
        }


        /// <summary>
        /// Adjust Level of Stack Y.
        /// </summary>
        /// <param name="blackPoint">Black point in percentage.</param>
        /// <param name="whitePoint">White point in percentage.</param>
        public void AdjustLevelY(double blackPoint, double whitePoint)
        {
            Map.StackY.AdjustLevel(blackPoint, whitePoint);
        }


        /// <summary>
        /// Removes filepath, template and stack image from X stack.
        /// </summary>
        public void CleanXStack()
        {
            Map.StackX.Filepath = null;
            Map.StackX.Template = null;
            Map.StackX.Stack = null;
        }


        /// <summary>
        /// Removes filepath, template and stack image from Y stack.
        /// </summary>
        public void CleanYStack()
        {
            Map.StackY.Filepath = null;
            Map.StackY.Filepath = null;
            Map.StackY.Filepath = null;
        }

    }
}