using System;

using System.Linq;

using System.Collections.Generic;

using Xunit;

​

namespace InternshipSpring2019

{

    /// <summary>

    /// This test has three exercises.

    /// The requirements are described in the relevant summary section of each method or class.

    /// You will need to complete the classes with the implementation.

    ///

    /// Before starting this test, press the "Fork" button in the toolbar above and then press save.

    /// 

    /// The Program.Main method checks the output of each exercise by asserting the result against the expected output.

    /// It will throw an Assert exception if the result is not the expected one.        

    /// 

    /// Fork this fiddle and when you feel ready save and send share the link with.

    /// You can create a dotnetfiddle account and use its Fork and Save features or just send an email at internship@maxcode.net with the complete implementation. 

    /// </summary>

    public static class Exercises

    {

        /// <summary>

        /// Given a list of integers, returns zero-based indices of any Pythagorean triplet.

        /// If there are no such elements, the method should return an empty collection.

        /// A Pythagorean triplet is when three numbers satisfy the following relation: a^2 + b^2 = c^2

        /// </summary>

        /// <example>

        /// For example, FindPythagoreans(new List<int>() { 1, 3, 4, 5, 12, 17, 13}) should return the following tuples of indices:

        /// -   (1, 2, 3) (because 3^2 + 4^2 = 5^2),

        /// -   (3, 4, 6) (because 5^2 + 12^2 = 13^2)

        /// </example>

        /// <param name = "elements">source list</param>        

        /// <returns>A pair containing the elements that matches the criteria.</returns>

        public static IEnumerable<Tuple<int, int, int>> FindPythagoreans(List<int> elements)

        {

            List<Tuple<int, int, int>> result = new List<Tuple<int, int, int>>();

            List<int> squares = new List<int>();

            foreach (var element in elements) {

                squares.Add(element * element); 

            }

            int squaresCount = squares.Count();

            for (var a = 0; a < squaresCount; a++) {

                for (var b = 0; b < squaresCount; b++) {

                    for (var c = 0; c < squaresCount; c++) {

                        if (squares[a] + squares[b] == squares[c] && a != b && b != c && a < b && b < c) {

                            result.Add(new Tuple<int, int, int>(a, b, c));

                        }

                    }

                }

            }

            return result;

        }

​

        /// <summary>

        /// Encrypts a message using the given key and returns the encrypted version.

        ///

        /// To encrypt the message first obtain from the given key the representation of the positions of each letter in key as they would be in an alphabetical order.

        /// For example, for the key `poker` we will get `43215` because of `ekopr` (sorted letters from the key).

        ///

        /// Encryption is done by putting all the letters in the message in a matrix with a fixed column count equal to the length of the numerical key.

        /// From this matrix, colums will be sorted ascending based on the numerical values in the keys.

        /// The result will be taken from the matrix, element by element.

        ///

        /// Let's encode "maxcodeinternship" using our key.

        /// 

        /// 4 3 2 1 5

        /// ---------

        /// m a x c o

        /// d e i n t

        /// e r n s h

        /// i p

        ///

        /// After using the key

        /// 

        /// 1 2 3 4 5

        /// ---------

        /// c x a m o

        /// n i e d t

        /// s n r e h

        ///     p i  

        ///

        /// which results "cxamoniedtsnreh  pi"

        ///

        /// </summary>

        /// <remarks>

        /// The message is never shorter than the key.

        /// </remarks>

        /// <param name = "message"></param>

        /// <param name = "key"></param>

        /// <returns>Encrypted data</returns>

        public static string Encrypt(string message, string key)

        {

            var divisionResult = message.Count() % key.Count();

            int auxAdd = 2;

            if (divisionResult == 0) {

                auxAdd = 1;

            }

            string[,] encryptionMatrix = new string[(message.Count() / key.Count()) + auxAdd, key.Count()];

            string result = "";

            long a = key[0];

            string sortedKey = String.Concat(key.OrderBy(c => c));

            int it = 0;

            int rows = encryptionMatrix.GetLength(0);

            int cols = encryptionMatrix.GetLength(1);

            for (int i = 0; i < cols; i++) {

                encryptionMatrix[0, i] = sortedKey.IndexOf(key[i]).ToString();

            }

            for (int i = 1; i < rows; i++) {

                for (int j = 0; j < cols; j++) {

                    if (it == message.Count()) {

                        encryptionMatrix[i, j] = " ";

                    } else {

                        encryptionMatrix[i, j] = message[it++].ToString();

                    }

                }

            }

            for (int i = 0; i < cols - 1; i++) {

                for (int j = i + 1; j < cols; j++) {

                    if (Convert.ToInt16(encryptionMatrix[0, i]) > Convert.ToInt16(encryptionMatrix[0, j])) {

                        for (int k = 0; k < rows; k++) {

                            var aux = encryptionMatrix[k, i];

                            encryptionMatrix[k, i] = encryptionMatrix[k, j];

                            encryptionMatrix[k, j] = aux;

                        }

                    }

                }

            }

            for (int i = 1; i < rows; i++) {

                for (int j = 0; j < cols; j++) {

                    result += encryptionMatrix[i, j];

                }

            }

            return result;

        }

​

        /// <summary>

        /// Implement a student ranking printer which receives a collection of students 

        /// and returns a formatted string with the rankings as a table with three columns:

        ///     -   rank : the position of the student

        ///     -   name : the name of the student formatted as "FirstName - LastName"

        ///     -   grade : the letter corresponding to the American style grade of the student's average.

        ///         -   < 5 -> F

        ///         -   >= 5 AND < 7 -> D

        ///         -   >= 7 AND < 8 -> C

        ///         -   >= 8 AND < 9 -> B

        ///         -   >= 9 AND <= 10 -> A

        ///         -   Every student will have at least one grade and all averages will be different

        /// 

        /// The header is separated from the content by a line of 20 '#'

        /// The new line separator should be '\n'

        /// </summary>

        /// <example>

        /// Given students = [

        ///     {

        ///         FirstName = Bob,

        ///         LastName = Ross,

        ///         Grades = [7, 8, 10]

        ///     },

        ///     {

        ///         FirstName = Mr,

        ///         LastName = T,

        ///         Grades = [9]

        ///     }]

        ///

        /// PrintRanking should return a string containing

        /// 

        /// Rank#Name#Average

        /// ####################

        /// 1#Mr - T#A

        /// 2#Bob - Ross#B

        /// 

        /// </example>

        /// <param name = "students">a colection of students</param>

        /// <returns>

        /// </returns>

        public class StudentRankingsPrinter

        {

            public StudentRankingsPrinter()

            {

            }

​

            public string PrintRankings(IEnumerable<Student> students)

            {

                return string.Empty;

            }

        }

​

        public class Student

        {

            public string FirstName;

            public string LastName;

            public double[] Grades;

            public Student(string firstName, string lastName, double[] grades)

            {

                FirstName = firstName;

                LastName = lastName;

                Grades = grades;

            }

        }

    }

​

    public class Program

    {

        public static void Main(string[] args)

        {

            ExerciseForFindPythagoreansWhenNone(new List<int>{1, 3});

            ExerciseForFindPythagoreans(new List<int>{1, 3, 4, 5, 12, 17, 13}, new[]{Tuple.Create(1, 2, 3), Tuple.Create(3, 4, 6)});

            ExerciseEncrypt("secretinformation", "crazy", "cseerntiofarmit on  ");

            ExerciseEncrypt("abcd", "abc", "abcd  ");

            ExerciseEncrypt("1234567890", "ba", "2143658709");

            ExerciseEncrypt("key", "key", "eky");

            ExercisePrintRanking(new[]{new Exercises.Student("Bob", "Ross", new[]{6.0, 8.0, 10.0})}, "Rank#Name#Average\n####################\n1#Bob - Ross#B");

            ExercisePrintRanking(new[]{new Exercises.Student("Bob", "Ross", new[]{7.0, 6.0, 8.5, 8.0}), new Exercises.Student("Rob", "Boss", new[]{9.0, 8.0})}, "Rank#Name#Average\n####################\n1#Rob - Boss#B\n2#Bob - Ross#C");

            Console.WriteLine("Well done!");

        }

​

        private static void ExerciseForFindPythagoreans(List<int> elements, Tuple<int, int, int>[] expectedAnyOf)

        {

            var result = Exercises.FindPythagoreans(elements);

            foreach (var pythagorean in result)

            {

                var containsResult = expectedAnyOf.Any(c => pythagorean.Item1 + pythagorean.Item2 + pythagorean.Item3 == c.Item1 + c.Item2 + c.Item3);

                Assert.True(containsResult, string.Format("The pair {0}, {1}, {2} does not match the criteria", pythagorean.Item1, pythagorean.Item2, pythagorean.Item3));

            }

        }

​

        private static void ExerciseForFindPythagoreansWhenNone(List<int> elements)

        {

            var result = Exercises.FindPythagoreans(elements);

            Assert.Empty(result);

        }

​

        private static void ExerciseEncrypt(string message, string key, string expected)

        {

            var encrypted = Exercises.Encrypt(message, key);

            Assert.Equal(expected, encrypted);

        }

​

        private static void ExercisePrintRanking(IEnumerable<Exercises.Student> students, string expected)

        {

            var printer = new Exercises.StudentRankingsPrinter();

            var rankings = printer.PrintRankings(students);

            Assert.Equal(expected, rankings);

        }

    }

}