//******************************************************************************************************
//  DerWriter.cs - Gbtc
//
//  Copyright © 2018, Grid Protection Alliance.  All Rights Reserved.
//
//  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See
//  the NOTICE file distributed with this work for additional information regarding copyright ownership.
//  The GPA licenses this file to you under the MIT License (MIT), the "License"; you may
//  not use this file except in compliance with the License. You may obtain a copy of the License at:
//
//      http://opensource.org/licenses/MIT
//
//  Unless agreed to in writing, the subject software distributed under the License is distributed on an
//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the
//  License for the specific language governing permissions and limitations.
//
//  Code Modification History:
//  ----------------------------------------------------------------------------------------------------
//  05/27/2018 - Steven E. Chisholm
//       Generated original version of source code.
//
//******************************************************************************************************

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Text;

namespace GSF.Security.Cryptography.X509
{
    [SuppressMessage("Microsoft.Design", "CA1001:TypesThatOwnDisposableFieldsShouldBeDisposable")]
    internal class DerWriter
    {
        private enum SectionMode
        {
            Sequence,
            Set,
            BitString,
            Tagged,
            Octet
        }
        private class Section : IDisposable
        {
            private DerWriter m_caller;
            private SectionMode m_mode;
            public Section(DerWriter caller, SectionMode mode)
            {
                m_caller = caller;
                m_mode = mode;
            }

            public void Dispose()
            {
                m_caller?.EndSection(m_mode);
                m_caller = null;
            }
        }
        private Stack<MemoryStream> m_stack = new Stack<MemoryStream>();

        private const int Integer = 0x02;
        private const int BitString = 0x03;
        private const int OctetString = 0x04;
        private const int Null = 0x05;
        private const int ObjectIdentifier = 0x06;
        private const int Sequence = 0x10;
        private const int Set = 0x11;

        private const int GeneralizedTime = 0x18;
        private const int Utf8String = 0x0c;

        private const int Constructed = 0x20;
        private const int Tagged = 0x80;

        private MemoryStream m_ms;

        public DerWriter()
        {
            m_ms = new MemoryStream();
        }

        private void EndSection(SectionMode mode)
        {
            byte[] data = m_ms.ToArray();
            m_ms = m_stack.Pop();
            switch (mode)
            {
                case SectionMode.Sequence:
                    WriteSequence(data);
                    break;
                case SectionMode.Set:
                    WriteSet(data);
                    break;
                case SectionMode.BitString:
                    Write(data);
                    break;
                case SectionMode.Octet:
                    WriteOctetString(data);
                    break;
                case SectionMode.Tagged:
                    WriteLength(data.Length);
                    m_ms.Write(data, 0, data.Length);
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(mode), mode, null);
            }

        }

        private void WriteLength(int length)
        {
            if (length > 127)
            {
                int size = 1;
                uint val = (uint)length;

                while ((val >>= 8) != 0)
                {
                    size++;
                }

                m_ms.WriteByte((byte)(size | 0x80));

                for (int i = (size - 1) * 8; i >= 0; i -= 8)
                {
                    m_ms.WriteByte((byte)(length >> i));
                }
            }
            else
            {
                m_ms.WriteByte((byte)length);
            }
        }

        private void WriteEncoded(int tag, byte[] bytes)
        {
            m_ms.WriteByte((byte)tag);
            WriteLength(bytes.Length);
            m_ms.Write(bytes, 0, bytes.Length);
        }

        public void Write(byte[] bitString)
        {
            m_ms.WriteByte(BitString);
            WriteLength(bitString.Length + 1);
            m_ms.WriteByte((byte)0);
            m_ms.Write(bitString, 0, bitString.Length);
        }

        public void Write(DateTime time)
        {
            WriteEncoded(GeneralizedTime, Encoding.ASCII.GetBytes(time.ToString("yyyyMMddHHmmss", CultureInfo.InvariantCulture) + "Z"));
        }

        public void WriteInteger(byte[] bigInt)
        {
            for (int x = 0; x < bigInt.Length; x++)
            {
                if (bigInt[x] != 0)
                {
                    if (bigInt[x] > 127) //Value is negative
                        x--;
                    byte[] newData = new byte[bigInt.Length - x];

                    if (x == -1)
                    {
                        Array.Copy(bigInt, 0, newData, 1, newData.Length-1);
                    }
                    else
                    {
                        Array.Copy(bigInt, x, newData, 0, newData.Length);
                    }

                    WriteEncoded(Integer, newData);
                    return;
                }
            }
            //The value is 0
            WriteEncoded(Integer, new byte[1]);
        }

        public void WriteInteger(long value)
        {
            WriteInteger(ToBytes(value));
        }
        private static byte[] ToBytes(long value)
        {
            if (value < 0)
                throw new Exception("Value must be positive");

            byte[] rv = BitConverter.GetBytes(value);
            if (BitConverter.IsLittleEndian)
            {
                Array.Reverse(rv);
            }
            return rv;
        }
        public void WriteNull()
        {
            WriteEncoded(Null, new byte[0]);
        }

        public IDisposable BeginTaggedObject(int tag)
        {
            m_ms.WriteByte((byte)(Constructed | Tagged | tag));
            m_stack.Push(m_ms);
            m_ms = new MemoryStream();
            return new Section(this, SectionMode.Tagged);
        }

        public IDisposable BeginSequence()
        {
            m_stack.Push(m_ms);
            m_ms = new MemoryStream();
            return new Section(this, SectionMode.Sequence);
        }

        public IDisposable BeginOctetString()
        {
            m_stack.Push(m_ms);
            m_ms = new MemoryStream();
            return new Section(this, SectionMode.Octet);
        }

        public void WriteOctetString(byte[] data)
        {
            m_ms.WriteByte(OctetString);
            WriteLength(data.Length);
            m_ms.Write(data, 0, data.Length);

        }

        public IDisposable BeginBitString()
        {
            m_stack.Push(m_ms);
            m_ms = new MemoryStream();
            return new Section(this, SectionMode.BitString);
        }

        public IDisposable BeginSet()
        {
            m_stack.Push(m_ms);
            m_ms = new MemoryStream();
            return new Section(this, SectionMode.Set);
        }

        public void WriteOID(string identifier)
        {
            string[] items = identifier.Split('.');

            var ms = new MemoryStream();
            for (int x = 1; x < items.Length; x++)
            {
                long value;
                if (x == 1)
                    value = int.Parse(items[0]) * 40 + int.Parse(items[1]);
                else
                    value = int.Parse(items[x]);

                WriteField(ms, value);
            }
            WriteEncoded(ObjectIdentifier, ms.ToArray());
        }

        private void WriteField(MemoryStream stream, long fieldValue)
        {
            //Write a 7-bit big endian value.
            byte[] result = new byte[9];
            int pos = 8;
            result[pos] = (byte)(fieldValue & 127);
            while (fieldValue >= 128)
            {
                fieldValue >>= 7;
                pos--;
                result[pos] = (byte)((fieldValue & 127) | 128);
            }
            stream.Write(result, pos, 9 - pos);
        }

        private void WriteSequence(byte[] data)
        {
            WriteEncoded(Sequence | Constructed, data);
        }

        private void WriteSet(byte[] data)
        {
            WriteEncoded(Set | Constructed, data);
        }

        public void Write(string value)
        {
            WriteEncoded(Utf8String, Encoding.UTF8.GetBytes(value));
        }

        public byte[] ToArray()
        {
            return m_ms.ToArray();
        }
    }
}