/// 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.Text.Json.Serialization;

namespace CoreLibrary
{
    /// <summary>
    /// Attachments class contains list of the attached data and also methods of processing the said data.
    /// Responsible for handling the whole list. For example getting the data relative to single slice.
    /// </summary>
    public class Attachments
    {
        public List<AttachedData> AttachmentList { 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="attachmentlist"></param>
        [JsonConstructor]
        public Attachments(List<AttachedData> attachmentlist)
        {
            AttachmentList = attachmentlist;
        }

        /// <summary>
        /// Parameterless constructor that only initializes the object.
        /// </summary>
        public Attachments()
        {
            AttachmentList = new ();
        }

        /// <summary>
        /// Changes filepaths to be relative to given filepath,
        /// </summary>
        /// <param name="relativeTo">Filepath that the paths are relative to</param>
        public void SetAttachmentRelation(string relativeTo)
        {
            foreach(AttachedData data in AttachmentList)
            {
                data.SetDataRelation(relativeTo);
            }
        }

        /// <summary>
        /// Adds attached data to this object,
        /// </summary>
        /// <param name="AD">Attached data to be added.</param>
        public void AddData(AttachedData AD)
        {
            AttachmentList.Add(AD);
        }


        /// <summary>
        /// Removes data by attached data name.
        /// </summary>
        /// <param name="dataName">Name of the removed data.</param>
        public void RemoveDataByName(string dataName)
        {
            var toBeRemoved = AttachmentList.Find(a => a.DataName == dataName);
            AttachmentList.Remove(toBeRemoved);
        }


        /// <summary>
        /// Removes attached data from list.
        /// </summary>
        /// <param name="AD">Attached data to be removed</param>
        public void RemoveData(AttachedData AD)
        {
            AttachmentList.Remove(AD);
        }


        /// <summary>
        /// Counts the number of attached data per coordinate.
        /// Doesn't count data that has coordinates smaller than 0 or above depth range
        /// </summary>
        /// <param name="xDepth">Depth of X-axis.</param>
        /// <param name="yDepth">Depth of Y-axis.</param>
        /// <param name="zDepth">Depth of Z-axis.</param>
        /// <returns></returns>
        public int[][] AttachementCount(int xDepth, int yDepth, int zDepth)
        {
            var marks = new int[3][];
            marks[0] = new int[xDepth];
            marks[1] = new int[yDepth];
            marks[2] = new int[zDepth];

            foreach (var AD in AttachmentList)
            {
                foreach (var vec in AD.AttachmentPoints)
                {
                    int x = (int)Math.Round(vec.X-1, 0);
                    int y = (int)Math.Round(vec.Y-1, 0);
                    int z = (int)Math.Round(vec.Z-1, 0);

                    if (x >= 0 && x < marks[0].Length && 
                        y >= 0 && y < marks[1].Length && 
                        z >= 0 && z < marks[2].Length)
                    {
                        marks[0][x] += 1;
                        marks[1][y] += 1;
                        marks[2][z] += 1;
                    }
                    
                    
                }
            }
            return marks;
        }


        /// <summary>
        /// Searches attachments with speficied Z coordinate.
        /// </summary>
        /// <param name="z">Z coordinate</param>
        /// <returns>List of attachments that fit the criteria.</returns>
        internal List<AttachedData> AttByZCoordinate(int z)
        {
            List<AttachedData> ls = new();
            foreach (AttachedData att in AttachmentList)
            {
                if (att.AttachmentPoints.Count <= 0) continue ;
                if (att.AttachmentPoints[0].Z == z) ls.Add(att);
            }

            return ls;
        }


        /// <summary>
        /// Returns Attached data by integer X-coordinates.
        /// </summary>
        /// <param name="x">X-axis depth.</param>
        /// <returns>Attached data by X-coordinates.</returns>
        internal List<AttachedData> AttByXCoordinate(int x)
        {
            List<AttachedData> ls = new();
            foreach (AttachedData att in AttachmentList)
            {
                if (att.AttachmentPoints.Count <= 0) continue;
                if (att.AttachmentPoints[0].X == x) ls.Add(att);
            }

            return ls;
        }


        /// <summary>
        /// Returns Attached data by integer Y-coordinates.
        /// </summary>
        /// <param name="y">Y-axis depth.</param>
        /// <returns>Attached data by Y-coordinates.</returns>
        internal List<AttachedData> AttByYCoordinate(int y)
        {
            List<AttachedData> ls = new();
            foreach (AttachedData att in AttachmentList)
            {
                if (att.AttachmentPoints.Count <= 0) continue;
                if (att.AttachmentPoints[0].Y == y) ls.Add(att);
            }

            return ls;
        }


        #nullable enable
        internal AttachedData? GetAttachment(string name)
        {
            foreach(AttachedData att in AttachmentList)
            {
                if (att.DataName.Equals(name.Trim())) return att;
            }
            return null;
        }
        #nullable disable
    }
}