#_lab1

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.IO;
using System.Numerics;
using System.Security.Cryptography;
using System.Text;

namespace GeneticsProject
{
    public struct GeneticData
    {
        public string name;
        public string organism;
        public string formula;
    }

    class Program
    {
        static List<GeneticData> data = new List<GeneticData>();
        static int count = 1;


        static string GetFormula(string proteinName)
        {
            foreach (GeneticData item in data)
            {
                if (item.name.Equals(proteinName)) return item.formula;
            }
            return null;
        }
        static void ReadGeneticData(string filename)
        {
            StreamReader reader = new StreamReader(filename);
            while (!reader.EndOfStream)
            {
                string line = reader.ReadLine();
                string[] fragments = line.Split('\t');
                GeneticData protein;
                protein.name = fragments[0];
                protein.organism = fragments[1];
                protein.formula = fragments[2];
                data.Add(protein);
                count++;
            }
            reader.Close();
        }
        static void ReadHandleCommands(string filename)
        {
            StreamReader reader = new StreamReader(filename);
            StreamWriter writer = new StreamWriter("genedata.txt");
            writer.WriteLine("Maksim Dragun");
            writer.WriteLine("Genetic Searching");
            int counter = 0;
            writer.WriteLine("================================================");
            while (!reader.EndOfStream)
            {
                string line = reader.ReadLine();
                counter++;
                string[] command = line.Split('\t');
                if (command[0].Equals("search"))
                {
                    writer.WriteLine($"{counter.ToString("D3")}   {"search"}   {Decoding(command[1])}");
                    writer.WriteLine("organism                      protein");
                    int index = Search(command[1]);
                    if (index != -1)
                        writer.WriteLine($"{data[index].organism}    {data[index].name}");
                    else
                        writer.WriteLine("NOT FOUND");
                    writer.WriteLine("================================================");
                }
                if (command[0].Equals("diff"))
                {
                    writer.WriteLine($"{counter.ToString("D3")}   {"diff"}   {command[1]}  {command[2]}");
                    int diffNum = Diff(command[1], command[2]);
                    writer.WriteLine("amino-acids difference:");
                    if (diffNum == -1)
                        writer.WriteLine("MISSING" + command[1]);
                    else if (diffNum == -2)
                        writer.WriteLine("MISSING" + command[2]);
                    else
                        writer.WriteLine($"{diffNum}");
                    writer.WriteLine("================================================");
                }
                if (command[0].Equals("mode"))
                {
                    writer.WriteLine($"{counter.ToString("D3")}   {"mode"}   {command[1]}");
                    string res = Mode(command[1]);
                    writer.WriteLine("amino - acid occurs:");
                    if (res == "no")
                        writer.WriteLine("MISSING" + command[1]);
                    else
                        writer.WriteLine(res);
                    writer.WriteLine("================================================");
                }
            }
            reader.Close();
            writer.Close();
        }
        static bool IsValid(string formula)
        {
            List<char> letters = new List<char>() { 'A', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'Y' };
            foreach (char ch in formula)
            {
                if (!letters.Contains(ch)) return false;
            }
            return true;
        }
        static string Encoding(string formula)
        {
            string encoded = String.Empty;
            for (int i = 0; i < formula.Length; i++)
            {
                char ch = formula[i];
                int count = 1;
                while (i < formula.Length - 1 && formula[i + 1] == ch)
                {
                    count++;
                    i++;
                }
                if (count > 2) encoded = encoded + count + ch;
                if (count == 1) encoded = encoded + ch;
                if (count == 2) encoded = encoded + ch + ch;

            }
            return encoded;

        }
        static string Decoding(string formula)
        {
            string decoded = String.Empty;
            for (int i = 0; i < formula.Length; i++)
            {
                if (char.IsDigit(formula[i]))
                {
                    char letter = formula[i + 1];
                    int conversion = formula[i] - '0';
                    for (int j = 0; j < conversion - 1; j++) decoded = decoded + letter;
                }
                else decoded = decoded + formula[i];
            }
            return decoded;
        }
        static int Search(string amino_acid)
        {
            string decoded = Decoding(amino_acid);
            for (int i = 0; i < data.Count; i++)
            {
                if (data[i].formula.Contains(decoded)) return i;
            }
            return -1;
        }
        static int Diff(string protein1, string protein2)
        {
            string  min, formula1 = "", formula2 = "";
            formula1 = GetFormula(protein1);
            formula2 = GetFormula(protein2);
            if (formula1 == "")
                return -1;
            if (formula2 == "")
                return -2;
            int minLength = Math.Min(formula1.Length, formula2.Length);
            int difference = 0;
            for(int j = 0; j < minLength; j++)
            {
                if (formula1[j] != formula2[j]) difference++;
            }
            int n = 1;
            difference += Math.Abs(formula1.Length - formula2.Length);

            return difference;
        }
        static string Mode(string protein)
        {
            string formula1 = "";
            formula1 = GetFormula(protein);
            if (formula1 == "")
            {
                return "no";
            }
            Dictionary<char, int> frequency = new Dictionary<char, int>();
            int max = 0; char maxAmino = ' ';
            for(int j = 0; j < formula1.Length; j++)
            {
                if (frequency.ContainsKey(formula1[j]))
                {
                    frequency[formula1[j]]++;
                }
                else
                {
                    frequency[formula1[j]] = 1;
                }
            }
            foreach(var c in frequency) {
                if (c.Value > max)
                {
                    max = c.Value;
                    maxAmino = c.Key;
                }
                else if (c.Value == max && c.Key < maxAmino)
                {
                    maxAmino = c.Key;
                }
            }

            string res = maxAmino + "      " + max;
            return res;
        }
        static void Main(string[] args)
        {
            ReadGeneticData("sequences.0.txt");
            ReadHandleCommands("commands.0.txt");
        }
    }
}