using System;
using System.IO;
using System.Reflection;
using System.Security.Cryptography;

namespace SharpCifs.Util.Sharpen
{
    public abstract class MessageDigest
	{
	    public void Digest (byte[] buffer, int o, int len)
		{
			byte[] d = Digest ();
			d.CopyTo (buffer, o);
		}

		public byte[] Digest (byte[] buffer)
		{
			Update (buffer);
			return Digest ();
		}

		public abstract byte[] Digest ();
		public abstract int GetDigestLength ();
		public static MessageDigest GetInstance (string algorithm)
		{
			switch (algorithm.ToLower ()) {
			case "sha-1":
                //System.Security.CryptographySHA1Managed not found
                //return new MessageDigest<SHA1Managed> ();
                return new MessageDigest<System.Security.Cryptography.SHA1>();
            case "md5":
                return new MessageDigest<Md5Managed> ();
            }
			throw new NotSupportedException (string.Format ("The requested algorithm \"{0}\" is not supported.", algorithm));
		}

		public abstract void Reset ();
		public abstract void Update (byte[] b);
		public abstract void Update (byte b);
		public abstract void Update (byte[] b, int offset, int len);
	}


	public class MessageDigest<TAlgorithm> : MessageDigest where TAlgorithm : HashAlgorithm //, new() //use static `Create` method
	{
		private TAlgorithm _hash;
        //private CryptoStream _stream; //don't work .NET Core
        private MemoryStream _stream;


        public MessageDigest ()
		{
			Init ();
		}

		public override byte[] Digest ()
		{
            //CryptoStream -> MemoryStream, needless method
            //_stream.FlushFinalBlock ();

            //HashAlgorithm.`Hash` property deleted
            //byte[] hash = _hash.Hash;
            byte[] hash = _hash.ComputeHash(_stream.ToArray());

            Reset ();
			return hash;
		}

		public void Dispose ()
		{
			if (_stream != null) {
				_stream.Dispose ();
			}
			_stream = null;
        }

        public override int GetDigestLength ()
		{
			return (_hash.HashSize / 8);
		}

		private void Init ()
		{
            //use static `Create` method
            //_hash = Activator.CreateInstance<TAlgorithm> ();
            var createMethod = typeof(TAlgorithm).GetRuntimeMethod("Create", new Type[0]);
            _hash = (TAlgorithm)createMethod.Invoke(null, new object[] {});

            //HashAlgorithm cannot cast `ICryptoTransform` on .NET Core, gave up using CryptoStream. 
            //_stream = new CryptoStream(Stream.Null, _hash, CryptoStreamMode.Write);
            //_stream = new CryptoStream(_tmpStream, (ICryptoTransform)_hash, CryptoStreamMode.Write);
            _stream = new MemoryStream();
        }

        public override void Reset ()
		{
			Dispose ();
			Init ();
		}

		public override void Update (byte[] input)
		{
			_stream.Write (input, 0, input.Length);
		}

		public override void Update (byte input)
		{
			_stream.WriteByte (input);
		}

		public override void Update (byte[] input, int index, int count)
		{
			if (count < 0)
				Console.WriteLine ("Argh!");
			_stream.Write (input, index, count);
		}
	}
}