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();

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

        public SRP6() { }

        private void GenerateIdentityHash(string username, string password)
        {
            IdentityHash = SRP6Helpers.Hash((Encoding.UTF8.GetBytes((username + ":" + password).ToUpper())));
        }

        public void Step1(string username = null, string password = null, string s = null, string v = null)
        {
            if (username != null && password != null)
                GenerateIdentityHash(username, password);

            // Generation de s = RAND()
            if (s == null)
                Salt = BigIntegerExtensions.CreateBigInteger(256, new Random());
            else
                Salt = BigIntegerExtensions.CreateBigInteger(s, 16);

            if (v == null)
            {
                // Generation de x = H(s | H(P))
                PrivateKey = SRP6Helpers.Hash(Salt.ToCleanByteArray().Combine(IdentityHash)).ToBigInteger();
                // Generation de v = g ^ x % N
                Verifier = Generator.ModPow(PrivateKey, Modulus);
            }
            else
                Verifier = BigIntegerExtensions.CreateBigInteger(v, 16);

            // Generation de k = 3
            Multiplier = new BigInteger(3);
            // Generation de b = RAND()
            ServerPrivateEphemeral = BigIntegerExtensions.GeneratePseudoPrime(128, 100, new Random());
            // Generation de B = kv + g^b
            ServerPublicEphemeral = Multiplier.Multiply(Verifier).Add(Generator.ModPow(ServerPrivateEphemeral, Modulus));
        }

        public void Step2(byte[] A, byte[] M1, string I)
        {
            // Generation de u = H(A | B)
            _sha1CSP.Initialize();
            byte[] u = _sha1CSP.ComputeHash(ByteExtensions.Combine(A, ServerPublicEphemeral.ToCleanByteArray()).ToArray(), 0, 32);
            Scrambler = new BigInteger(u.Concat(new byte[] { 0 }).ToArray());

            // Generation de S = (A * v^u) ^ b % N


            //// Generation de K = H(S))
            //_sha1CSP.Initialize();

            // 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)

            // Generation de M2 = H(A | M1 | K)
        }
    }
}