// /***************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
// Filename       : DI.cs
// Author(s)      : Natalia Portillo <claunia@claunia.com>
//
// Component      : Device structures decoders.
//
// --[ Description ] ----------------------------------------------------------
//
//     Decodes Blu-ray Disc Information.
//
// --[ License ] --------------------------------------------------------------
//
//     This library is free software; you can redistribute it and/or modify
//     it under the terms of the GNU Lesser General Public License as
//     published by the Free Software Foundation; either version 2.1 of the
//     License, or (at your option) any later version.
//
//     This library is distributed in the hope that it will be useful, but
//     WITHOUT ANY WARRANTY; without even the implied warranty of
//     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
//     Lesser General Public License for more details.
//
//     You should have received a copy of the GNU Lesser General Public
//     License along with this library; if not, see <http://www.gnu.org/licenses/>.
//
// ----------------------------------------------------------------------------
// Copyright © 2011-2019 Natalia Portillo
// ****************************************************************************/

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Text;
using DiscImageChef.Console;

namespace DiscImageChef.Decoders.Bluray
{
    /// <summary>
    ///     Information from the following standards:
    ///     ANSI X3.304-1997
    ///     T10/1048-D revision 9.0
    ///     T10/1048-D revision 10a
    ///     T10/1228-D revision 7.0c
    ///     T10/1228-D revision 11a
    ///     T10/1363-D revision 10g
    ///     T10/1545-D revision 1d
    ///     T10/1545-D revision 5
    ///     T10/1545-D revision 5a
    ///     T10/1675-D revision 2c
    ///     T10/1675-D revision 4
    ///     T10/1836-D revision 2g
    /// </summary>
    [SuppressMessage("ReSharper", "InconsistentNaming")]
    [SuppressMessage("ReSharper", "MemberCanBeInternal")]
    [SuppressMessage("ReSharper", "MemberCanBePrivate.Global")]
    [SuppressMessage("ReSharper", "NotAccessedField.Global")]
    public static class DI
    {
        #region Private constants
        const string DiscTypeBDROM = "BDO";
        const string DiscTypeBDRE  = "BDW";
        const string DiscTypeBDR   = "BDR";

        /// <summary>
        ///     Disc Information Unit Identifier "DI"
        /// </summary>
        const ushort DIUIdentifier = 0x4449;
        #endregion Private constants

        #region Public methods
        public static DiscInformation? Decode(byte[] DIResponse)
        {
            if(DIResponse == null) return null;

            if(DIResponse.Length != 4100)
            {
                DicConsole.DebugWriteLine("BD Disc Information decoder",
                                          "Found incorrect Blu-ray Disc Information size ({0} bytes)",
                                          DIResponse.Length);
                return null;
            }

            DiscInformation decoded = new DiscInformation();

            BigEndianBitConverter.IsLittleEndian = BitConverter.IsLittleEndian;

            decoded.DataLength = BigEndianBitConverter.ToUInt16(DIResponse, 0);
            decoded.Reserved1  = DIResponse[2];
            decoded.Reserved2  = DIResponse[3];

            int                        offset = 4;
            List<DiscInformationUnits> units  = new List<DiscInformationUnits>();

            while(true)
            {
                if(offset >= 4100) break;

                DiscInformationUnits unit = new DiscInformationUnits
                {
                    Signature = BigEndianBitConverter.ToUInt16(DIResponse, 0 + offset)
                };

                if(unit.Signature != DIUIdentifier) break;

                unit.Format             = DIResponse[2 + offset];
                unit.UnitsPerBlock      = (byte)((DIResponse[3 + offset] & 0xF8) >> 3);
                unit.Layer              = (byte)(DIResponse[3 + offset] & 0x07);
                unit.Legacy             = DIResponse[4 + offset];
                unit.Sequence           = DIResponse[5 + offset];
                unit.Continuation       = (DIResponse[6       + offset] & 0x80) == 0x80;
                unit.Length             = (byte)(DIResponse[6 + offset] & 0x7F);
                unit.Reserved           = DIResponse[7 + offset];
                unit.DiscTypeIdentifier = new byte[3];
                Array.Copy(DIResponse, 8 + offset, unit.DiscTypeIdentifier, 0, 3);
                unit.DiscSize         = (BluSize)((DIResponse[11 + offset] & 0xC0) >> 6);
                unit.DiscClass        = (byte)((DIResponse[11    + offset] & 0x30) >> 4);
                unit.DiscVersion      = (byte)(DIResponse[11 + offset] & 0x0F);
                unit.Layers           = (byte)((DIResponse[12        + offset] & 0xF0) >> 4);
                unit.DvdLayer         = (HybridLayer)((DIResponse[13 + offset] & 0xC0) >> 6);
                unit.CdLayer          = (HybridLayer)((DIResponse[13 + offset] & 0x30) >> 4);
                unit.ChannelLength    = (ChannelLength)(DIResponse[13 + offset] & 0x0F);
                unit.Polarity         = DIResponse[14 + offset];
                unit.RecordedPolarity = DIResponse[14 + offset];
                unit.Bca              = (byte)(DIResponse[16 + offset] & 0x0F);
                unit.MaxTransfer      = DIResponse[17 + offset];
                unit.LastPsn = (uint)((DIResponse[20 + offset] << 24) + (DIResponse[21 + offset] << 16) +
                                      (DIResponse[22 + offset] << 8)  + DIResponse[23 + offset]);
                // TODO: In -R/-RE how does this relate to layer size???
                unit.FirstAun = (uint)((DIResponse[24 + offset] << 24) + (DIResponse[25 + offset] << 16) +
                                       (DIResponse[26 + offset] << 8)  + DIResponse[27 + offset]);
                unit.LastAun = (uint)((DIResponse[28 + offset] << 24) + (DIResponse[29 + offset] << 16) +
                                      (DIResponse[30 + offset] << 8)  + DIResponse[31 + offset]);
                switch(Encoding.ASCII.GetString(unit.DiscTypeIdentifier))
                {
                    case DiscTypeBDROM:
                    {
                        unit.FormatDependentContents = new byte[32];
                        Array.Copy(DIResponse, 32 + offset, unit.FormatDependentContents, 0, 32);
                        break;
                    }
                    case DiscTypeBDRE:
                    case DiscTypeBDR:
                    {
                        unit.FormatDependentContents = new byte[66];
                        Array.Copy(DIResponse, 32 + offset, unit.FormatDependentContents, 0, 66);
                        unit.ManufacturerID = new byte[6];
                        Array.Copy(DIResponse, 100 + offset, unit.ManufacturerID, 0, 6);
                        unit.MediaTypeID = new byte[3];
                        Array.Copy(DIResponse, 106 + offset, unit.MediaTypeID, 0, 3);
                        unit.TimeStamp             = BigEndianBitConverter.ToUInt16(DIResponse, 109 + offset);
                        unit.ProductRevisionNumber = DIResponse[111                                 + offset];

                        offset += 14;
                        break;
                    }
                    default:
                    {
                        DicConsole.DebugWriteLine("BD Disc Information decoder",
                                                  "Found unknown disc type identifier \"{0}\"",
                                                  Encoding.ASCII.GetString(unit.DiscTypeIdentifier));
                        break;
                    }
                }

                units.Add(unit);

                offset += unit.Length;
            }

            if(units.Count <= 0) return decoded;

            decoded.Units = new DiscInformationUnits[units.Count];
            for(int i = 0; i < units.Count; i++) decoded.Units[i] = units[i];

            return decoded;
        }

        public static string Prettify(DiscInformation? DIResponse)
        {
            if(DIResponse == null) return null;

            DiscInformation response = DIResponse.Value;

            StringBuilder sb = new StringBuilder();

            foreach(DiscInformationUnits unit in response.Units)
            {
                sb.AppendFormat("DI Unit Sequence: {0}", unit.Sequence).AppendLine();
                sb.AppendFormat("DI Unit Format: 0x{0:X2}", unit.Format).AppendLine();
                sb.AppendFormat("There are {0} per block", unit.UnitsPerBlock).AppendLine();
                sb.AppendFormat("This DI refers to layer {0}", unit.Layer).AppendLine();
                if(Encoding.ASCII.GetString(unit.DiscTypeIdentifier) == DiscTypeBDRE)
                    sb.AppendFormat("Legacy value: 0x{0:X2}", unit.Legacy).AppendLine();
                sb.AppendLine(unit.Continuation ? "This DI continues previous unit" : "This DI starts a new unit");
                sb.AppendFormat("DI Unit is {0} bytes", unit.Length).AppendLine();
                sb.AppendFormat("Disc type identifier: \"{0}\"", Encoding.ASCII.GetString(unit.DiscTypeIdentifier))
                  .AppendLine();
                switch(unit.DiscSize)
                {
                    case BluSize.OneTwenty:
                        sb.AppendLine("Disc size: 120mm");
                        break;
                    case BluSize.Eighty:
                        sb.AppendLine("Disc size: 80mm");
                        break;
                    default:
                        sb.AppendFormat("Disc size: Unknown code {0}", (byte)unit.DiscSize).AppendLine();
                        break;
                }

                sb.AppendFormat("Disc class: {0}", unit.DiscClass).AppendLine();
                sb.AppendFormat("Disc version: {0}", unit.DiscVersion).AppendLine();
                sb.AppendFormat("This disc has {0} layers", unit.Layers).AppendLine();
                switch(unit.DvdLayer)
                {
                    case HybridLayer.None:
                        sb.AppendLine("This disc does not contain a DVD layer.");
                        break;
                    case HybridLayer.ReadOnly:
                        sb.AppendLine("This disc contains a DVD-ROM layer.");
                        break;
                    case HybridLayer.Recordable:
                        sb.AppendLine("This disc contains a DVD-R layer.");
                        break;
                    case HybridLayer.Rewritable:
                        sb.AppendLine("This disc contains a DVD-RW layer.");
                        break;
                }

                switch(unit.CdLayer)
                {
                    case HybridLayer.None:
                        sb.AppendLine("This disc does not contain a CD layer.");
                        break;
                    case HybridLayer.ReadOnly:
                        sb.AppendLine("This disc contains a CD-ROM layer.");
                        break;
                    case HybridLayer.Recordable:
                        sb.AppendLine("This disc contains a CD-R layer.");
                        break;
                    case HybridLayer.Rewritable:
                        sb.AppendLine("This disc contains a CD-RW layer.");
                        break;
                }

                switch(unit.ChannelLength)
                {
                    case ChannelLength.Seventy:
                        sb.AppendLine("Disc uses a 74.5nm channel giving 25 Gb per layer.");
                        break;
                    case ChannelLength.Sixty:
                        sb.AppendLine("Disc uses a 69.0nm channel giving 27 Gb per layer.");
                        break;
                    default:
                        sb.AppendFormat("Disc uses unknown channel length with code {0}", (byte)unit.ChannelLength)
                          .AppendLine();
                        break;
                }

                switch(unit.Polarity)
                {
                    case 0:
                        sb.AppendLine("Disc uses positive polarity.");
                        break;
                    case 1:
                        sb.AppendLine("Disc uses negative polarity.");
                        break;
                    default:
                        sb.AppendFormat("Disc uses unknown polarity with code {0}", unit.Polarity).AppendLine();
                        break;
                }

                if(Encoding.ASCII.GetString(unit.DiscTypeIdentifier) == DiscTypeBDR)
                    switch(unit.RecordedPolarity)
                    {
                        case 0:
                            sb.AppendLine("Recorded marks have a lower reflectivity than unrecorded ones (HTL disc).");
                            break;
                        case 1:
                            sb.AppendLine("Recorded marks have a higher reflectivity than unrecorded ones (LTH disc).");
                            break;
                        default:
                            sb.AppendFormat("Disc uses unknown recorded reflectivity polarity with code {0}",
                                            unit.RecordedPolarity).AppendLine();
                            break;
                    }

                switch(unit.Bca)
                {
                    case 0:
                        sb.AppendLine("Disc doesn't have a BCA.");
                        break;
                    case 1:
                        sb.AppendLine("Disc has a BCA.");
                        break;
                    default:
                        sb.AppendFormat("Disc uses unknown BCA code {0}", unit.Bca).AppendLine();
                        break;
                }

                if(unit.MaxTransfer > 0)
                    sb.AppendFormat("Disc has a maximum transfer rate of {0} Mbit/sec.", unit.MaxTransfer).AppendLine();
                else sb.AppendLine("Disc does not specify a maximum transfer rate.");

                sb.AppendFormat("Last user data PSN for disc: {0}", unit.LastPsn).AppendLine();
                sb.AppendFormat("First address unit number of data zone in this layer: {0}", unit.FirstAun)
                  .AppendLine();
                sb.AppendFormat("Last address unit number of data zone in this layer: {0}", unit.LastAun).AppendLine();

                if(Encoding.ASCII.GetString(unit.DiscTypeIdentifier) == DiscTypeBDR ||
                   Encoding.ASCII.GetString(unit.DiscTypeIdentifier) == DiscTypeBDRE)
                {
                    sb.AppendFormat("Disc manufacturer ID: \"{0}\"", Encoding.ASCII.GetString(unit.ManufacturerID))
                      .AppendLine();
                    sb.AppendFormat("Disc media type ID: \"{0}\"", Encoding.ASCII.GetString(unit.MediaTypeID))
                      .AppendLine();
                    sb.AppendFormat("Disc timestamp: 0x{0:X2}", unit.TimeStamp).AppendLine();
                    sb.AppendFormat("Disc product revison number: {0}", unit.ProductRevisionNumber).AppendLine();
                }

                sb.AppendFormat("Blu-ray DI Unit format dependent contents as hex follows:");
                sb.AppendLine(PrintHex.ByteArrayToHexArrayString(unit.FormatDependentContents, 80));
            }

            return sb.ToString();
        }

        public static string Prettify(byte[] DIResponse) => Prettify(Decode(DIResponse));
        #endregion Public methods

        #region Public structures
        public struct DiscInformation
        {
            /// <summary>
            ///     Bytes 0 to 1
            ///     Always 4098
            /// </summary>
            public ushort DataLength;
            /// <summary>
            ///     Byte 2
            ///     Reserved
            /// </summary>
            public byte Reserved1;
            /// <summary>
            ///     Byte 3
            ///     Reserved
            /// </summary>
            public byte Reserved2;
            /// <summary>
            ///     Byte 4 to 4099
            ///     Disc information units
            /// </summary>
            public DiscInformationUnits[] Units;
        }

        public struct DiscInformationUnits
        {
            /// <summary>
            ///     Byte 0
            ///     "DI"
            /// </summary>
            public ushort Signature;
            /// <summary>
            ///     Byte 2
            ///     Disc information format
            /// </summary>
            public byte Format;
            /// <summary>
            ///     Byte 3, bits 7 to 3
            ///     Number of DI units per block
            /// </summary>
            public byte UnitsPerBlock;
            /// <summary>
            ///     Byte 3, bits 2 to 0
            ///     Layer this DI refers to
            /// </summary>
            public byte Layer;
            /// <summary>
            ///     Byte 4
            ///     Reserved for BD-ROM, legacy information for BD-R/-RE
            /// </summary>
            public byte Legacy;
            /// <summary>
            ///     Byte 5
            ///     Sequence number for this DI unit
            /// </summary>
            public byte Sequence;
            /// <summary>
            ///     Byte 6, bit 7
            ///     If set this DI is a continuation of the previous one
            /// </summary>
            public bool Continuation;
            /// <summary>
            ///     Byte 6, bits 6 to 0
            ///     Number of bytes used by this DI unit, should be 64 for BD-ROM and 112 for BD-R/-RE
            /// </summary>
            public byte Length;
            /// <summary>
            ///     Byte 7
            ///     Reserved
            /// </summary>
            public byte Reserved;
            /// <summary>
            ///     Bytes 8 to 10
            ///     Disc type identifier
            /// </summary>
            public byte[] DiscTypeIdentifier;
            /// <summary>
            ///     Byte 11, bits 7 to 6
            ///     Disc size
            /// </summary>
            public BluSize DiscSize;
            /// <summary>
            ///     Byte 11, bits 5 to 4
            ///     Disc class
            /// </summary>
            public byte DiscClass;
            /// <summary>
            ///     Byte 11, bits 3 to 0
            ///     Disc version
            /// </summary>
            public byte DiscVersion;
            /// <summary>
            ///     Byte 12, bits 7 to 4
            ///     Layers in this disc
            /// </summary>
            public byte Layers;
            /// <summary>
            ///     Byte 12, bits 3 to 0
            ///     Reserved
            /// </summary>
            public byte Reserved2;
            /// <summary>
            ///     Byte 13, bits 7 to 6
            ///     DVD layer
            /// </summary>
            public HybridLayer DvdLayer;
            /// <summary>
            ///     Byte 13, bits 5 to 4
            ///     CD layer
            /// </summary>
            public HybridLayer CdLayer;
            /// <summary>
            ///     Byte 13, bits 3 to 0
            ///     Channel length
            /// </summary>
            public ChannelLength ChannelLength;
            /// <summary>
            ///     Byte 14
            ///     Polarity
            /// </summary>
            public byte Polarity;
            /// <summary>
            ///     Byte 15
            ///     Recorded polarity
            /// </summary>
            public byte RecordedPolarity;
            /// <summary>
            ///     Byte 16, bits 7 to 4
            ///     Reserved
            /// </summary>
            public byte Reserved3;
            /// <summary>
            ///     Byte 16, bits 3 to 0
            ///     If 0 no BCA, if 1 BCA, rest not defined
            /// </summary>
            public byte Bca;
            /// <summary>
            ///     Byte 17
            ///     Maximum transfer speed in megabits/second, 0 if no maximum
            /// </summary>
            public byte MaxTransfer;
            /// <summary>
            ///     Bytes 18 to 19
            ///     Reserved
            /// </summary>
            public ushort Reserved4;
            /// <summary>
            ///     Bytes 20 to 23
            ///     Last user data PSN for disc
            /// </summary>
            public uint LastPsn;
            /// <summary>
            ///     Bytes 24 to 27
            ///     First address unit number of data zone in this layer
            /// </summary>
            public uint FirstAun;
            /// <summary>
            ///     Bytes 28 to 31
            ///     Last address unit number of data zone in this layer
            /// </summary>
            public uint LastAun;
            /// <summary>
            ///     Bytes 32 to 63 for BD-ROM, bytes 32 to 99 for BD-R/-RE
            ///     Format dependent contents, disclosed in private blu-ray specifications
            /// </summary>
            public byte[] FormatDependentContents;
            /// <summary>
            ///     Bytes 100 to 105, BD-R/-RE only
            ///     Manufacturer ID
            /// </summary>
            public byte[] ManufacturerID;
            /// <summary>
            ///     Bytes 106 to 108, BD-R/-RE only
            ///     Media type ID
            /// </summary>
            public byte[] MediaTypeID;
            /// <summary>
            ///     Bytes 109 to 110, BD-R/-RE only
            ///     Timestamp
            /// </summary>
            public ushort TimeStamp;
            /// <summary>
            ///     Byte 111
            ///     Product revision number
            /// </summary>
            public byte ProductRevisionNumber;
        }
        #endregion Public structures

        public enum BluSize : byte
        {
            /// <summary>120mm</summary>
            OneTwenty = 0,
            /// <summary>80mm</summary>
            Eighty = 1
        }

        public enum HybridLayer : byte
        {
            /// <summary>No hybrid layer</summary>
            None = 0,
            /// <summary>-ROM layer</summary>
            ReadOnly = 1,
            /// <summary>-R layer</summary>
            Recordable = 2,
            /// <summary>-RW layer</summary>
            Rewritable = 3
        }

        public enum ChannelLength : byte
        {
            /// <summary>74.5nm channel or 25Gb/layer</summary>
            Seventy = 1,
            /// <summary>69.0nm channel or 27Gb/layer</summary>
            Sixty = 2
        }
    }
}