using SharpCore.Framework.DataExtensions;
using System;
using System.Collections.Generic;
using System.Numerics;
using System.Security.Cryptography;
using System.Text;
using System.Linq;
using SharpCore.Framework.Converters;

namespace SharpCore.Framework.Cryptography.SRP6
{
    public class SRP6
    {
        private SHA1CryptoServiceProvider _sha1CSP = new SHA1CryptoServiceProvider();
        private RandomNumberGenerator random = RNGCryptoServiceProvider.Create();

        #region Server side Challenge properties
        public byte[] N { get => Modulus.ToCleanByteArray(); }
        public byte[] B { get => ServerPublicEphemeral.ToCleanByteArray(); }
        public byte[] b { get => ServerPrivateEphemeral.ToCleanByteArray(); }
        public byte[] g { get => Generator.ToCleanByteArray(); }
        public byte[] s { get => Salt.ToCleanByteArray(); }
        public byte[] v { get => Verifier.ToCleanByteArray(); }
        public byte[] A { get => ClientPublicEphemeral.ToCleanByteArray(); }
        public byte[] M1 { get => ClientSessionKeyProof.ToCleanByteArray(); }
        public byte[] M2 { get => ServerSessionKeyProof.ToCleanByteArray(); }
        public byte[] K { get => SessionKey.ToCleanByteArray(); }
        private byte[] I;
        #endregion

        private BigInteger Modulus { get; } = BigIntegerExtensions.CreateBigInteger("894B645E89E1535BBDAD5B8B290650530801B18EBFBF5E8FAB3C82872A3E9BB7", 16); // N
        private BigInteger Generator { get; } = new BigInteger(7); // g
        private BigInteger Salt { get; set; } // s
        private BigInteger Verifier { get; set; } // v
        private BigInteger ServerPublicEphemeral { get; set; } // B
        private BigInteger ServerPrivateEphemeral { get; set; } // b
        private BigInteger PrivateKey { get; set; } // x
        private BigInteger Multiplier { get; set; } = new BigInteger(3); //
        private BigInteger Scrambler { get; set; } // u
        private BigInteger SessionKey { get; set; } // K
        private BigInteger ClientSessionKeyProof { get; set; } // M1
        private BigInteger ServerSessionKeyProof { get; set; } // M2
        private BigInteger ClientPublicEphemeral { get; set; } // A
        private byte[] IdentityHash { get; set; }

        public SRP6() { }

        public void Step1(string username = null, string password = null, string salt = null, string verifier = null)
        {
            // Generation de s = RAND()
            if (salt == null)
                CalculateS();
            else
                Salt = BigInteger.Parse("0" + salt, System.Globalization.NumberStyles.HexNumber);

            if (verifier == null)
                CalculateV(username, password);
            else
                Verifier = BigInteger.Parse("0" + verifier, System.Globalization.NumberStyles.HexNumber);

            // Generation de b = RAND()
            byte[] bTmp;
            random.GetBytes(bTmp = new byte[20]);
            ServerPrivateEphemeral = MakeBigInteger(bTmp);
            // Generation de B = kv + g^b % N
            byte[] BTmp = new byte[32];
            BTmp = GetBytes(((Multiplier * Verifier + BigInteger.ModPow(Generator, ServerPrivateEphemeral, Modulus)) % Modulus).ToByteArray());
            ServerPublicEphemeral = MakeBigInteger(BTmp);
        }

        public void CalculateS()
        {
            byte[] sTmp;
            random.GetBytes(sTmp = new byte[32]);
            Salt = MakeBigInteger(sTmp);
        }

        public void CalculateV(string username, string password)
        {
            // Generation de x = H(s | H(P))
            var p = Encoding.UTF8.GetBytes(username + ":" + password);
            PrivateKey = MakeBigInteger(SHA1.Create().ComputeHash(CombineData(s, SHA1.Create().ComputeHash(p))));
            // Generation de v = g ^ x % N
            Verifier = BigInteger.ModPow(Generator, PrivateKey, Modulus);
        }

        public void CalculateU(byte[] A)
        {
            ClientPublicEphemeral = MakeBigInteger(A);
            // Generation de u = H(A | B)
            byte[] u = SHA1.Create().ComputeHash(CombineData(A, B));
            Scrambler = MakeBigInteger(u);
        }

        public void CalculateK()
        {
            // Generation de S = (A * v^u) ^ b % N
            BigInteger p1 = ClientPublicEphemeral * BigInteger.ModPow(Verifier, Scrambler, Modulus); // (A * v^u)
            byte[] ss = BigInteger.ModPow(p1, ServerPrivateEphemeral, Modulus).ToByteArray();

            // Generation de K
            byte[] t = new byte[32];
            Buffer.BlockCopy(ss, 0, t, 0, ss.Length);
            byte[] t1 = new byte[16];
            byte[] vK = new byte[40];

            for (int i = 0; i < 16; i++)
            {
                t1[i] = t[i * 2];
            }

            t1 = SHA1.Create().ComputeHash(t1, 0, 16);

            for (int i = 0; i < 20; i++)
            {
                vK[i * 2] = t1[i];
            }

            for (int i = 0; i < 16; i++)
            {
                t1[i] = t[i * 2 + 1];
            }

            t1 = SHA1.Create().ComputeHash(t1, 0, 16);

            for (int i = 0; i < 20; i++)
            {
                vK[i * 2 + 1] = t1[i];
            }

            SessionKey = MakeBigInteger(vK);
        }

        public void CalculateM1(string username)
        {
            // Generation de M1
            //Client -> Serveur : M = H(H(N) xor H(g), H(I), s, A, B, K)  (xor correspond au OU exclusif)
            //Serveur->Client : H(A, M, K)
            byte[] HN = SHA1.Create().ComputeHash(N);
            byte[] Hg = SHA1.Create().ComputeHash(g);
            byte[] HI = SHA1.Create().ComputeHash(Encoding.UTF8.GetBytes(username));

            for (int i = 0; i < HN.Length; i++)
                HN[i] ^= Hg[i];

            byte[] m1 = SHA1.Create().ComputeHash(CombineData(HN, HI, s, A, B, K));
            ClientSessionKeyProof = MakeBigInteger(m1);
        }

        public void CalculateM2(byte[] m1)
        {
            // Generation de M2 = H(A | M1 | K)
            byte[] m2 = SHA1.Create().ComputeHash(CombineData(A, m1, K));
            ServerSessionKeyProof = MakeBigInteger(m2);
        }

       #region Helpers
        private byte[] GetBytes(byte[] data, int count = 32)
        {
            if (data.Length <= count)
                return data;

            var bytes = new byte[count];

            Buffer.BlockCopy(data, 0, bytes, 0, count);

            return bytes;
        }

        private BigInteger MakeBigInteger(byte[] data)
        {
            return new BigInteger(CombineData(data, new byte[] { 0 }));
        }

        private byte[] CombineData(byte[] data, byte[] data2)
        {
            return new byte[0].Concat(data).Concat(data2).ToArray();
        }

        private byte[] CombineData(byte[] data, byte[] data2, byte[] data3)
        {
            return new byte[0].Concat(data).Concat(data2).Concat(data3).ToArray();
        }

        private byte[] CombineData(byte[] data, byte[] data2, byte[] data3, byte[] data4)
        {
            return new byte[0].Concat(data).Concat(data2).Concat(data3).Concat(data4).ToArray();
        }

        private byte[] CombineData(byte[] data, byte[] data2, byte[] data3, byte[] data4, byte[] data5, byte[] data6)
        {
            return new byte[0].Concat(data).Concat(data2).Concat(data3).Concat(data4).Concat(data5).Concat(data6).ToArray();
        }
        #endregion
    }
}