using System.Text;

namespace m3uTool
{
    /// <summary>
    ///FAAC 1.24.1 (May 17 2005) UNSTABLE
    ///
    ///Usage: faac [options] infiles ...
    ///Options:
    ///  -q <quality>  Set quantizer quality.
    ///  -b <bitrate>  Set average bitrate to x kbps. (ABR, lower quality mode)
    ///  -c <freq>     Set the bandwidth in Hz. (default=automatic)
    ///  -o X          Set output file to X (only for one input file)
    ///  -r            Use RAW AAC output file.
    ///  -P            Raw PCM input mode (default 44100Hz 16bit stereo).
    ///  -R            Raw PCM input rate.
    ///  -B            Raw PCM input sample size (8, 16 (default), 24 or 32bits).
    ///  -C            Raw PCM input channels.
    ///  -X            Raw PCM swap input bytes
    ///  -I <C,LF>     Input channel config, default is 3,4 (Center third, LF fourth)
    ///
    ///MP4 specific options:
    ///  -w            Wrap AAC data in MP4 container. (default for *.mp4 and *.m4a)
    ///  --artist X    Set artist to X
    ///  --writer X    Set writer to X
    ///  --title X     Set title to X
    ///  --genre X     Set genre to X
    ///  --album X     Set album to X
    ///  --compilation Set compilation
    ///  --track X     Set track to X (number/total)
    ///  --disc X      Set disc to X (number/total)
    ///  --year X      Set year to X
    ///  --cover-art X Read cover art from file X
    ///  --comment X   Set comment to X
    /// </summary>
    public class Mp4EncodingOptions : ProcessArguments
    {
        #region Private variables

        /// <summary>
        /// Set album to X  --album X
        /// </summary>
        private string mAlbum;

        /// <summary>
        /// Set artist to X  --artist X 
        /// </summary>
        private string mArtist;

        /// <summary>
        /// The bandwidth in Hz -c [freq]
        /// </summary>
        private SampleRateFrequency mBandwidth = SampleRateFrequency.Hz_0;

        /// <summary>
        /// BitRate -b [bitrate]
        /// </summary>
        private int mBitrate = int.MinValue;

        /// <summary>
        /// Set comment to X  --comment X
        /// </summary>
        private string mComment;

        /// <summary>
        /// Set compilation  --compilation
        /// </summary> 
        private string mCompilation;

        /// <summary>
        /// Load cover art from filename  --cover-art X
        /// </summary>
        private string mCoverArtFilename;

        /// <summary>
        /// Set disc to X (number/total)  --disc X
        /// </summary>
        private string mDisc;

        /// <summary>
        /// Set genre to X  --genre X
        /// </summary>
        private string mGenre;

        /// <summary>
        /// Files to use for input
        /// </summary>
        private string[] mInfiles;

        /// <summary>
        /// The output filename (only for one input file) -o [filename]
        /// </summary>
        private string mOutputFilename;

        /// <summary>
        /// Quantinizer Quality -q [quality]
        /// </summary>
        private int mQuantinizerQuality = int.MinValue;

        /// <summary>
        /// Raw PCM input channels -C
        /// </summary>
        private ChannelMode mRawInputChannels;

        /// <summary>
        /// Raw PCM input mode (default 44100Hz 16bit stereo) -P
        /// </summary>
        private bool mRawPCMInputMode;

        /// <summary>
        /// Raw PCM input rate (default 16) -B
        /// </summary>
        private int mRawPCMInputSampleRate = 16;

        /// <summary>
        /// Raw PCMInputSampleSize (default 44100Hz 16bit stereo) -R
        /// </summary>
        private SampleRateFrequency mRawPCMInputSampleSize = SampleRateFrequency.Hz_44100;

        /// <summary>
        /// Raw PCM swap input bytes -X
        /// </summary>
        private bool mRawPCMSwapInputBytes;

        /// <summary>
        /// Set title to X  --title X
        /// </summary>
        private string mTitle;

        /// <summary>
        /// Set track to X (number/total)  --track X
        /// </summary>
        private string mTrack;

        /// <summary>
        /// Wrap AAC data in MP4 container. (default for *.mp4 and *.m4a) -w
        /// </summary>
        private bool mWrapAACDataInMp4;

        /// <summary>
        /// Set writer to X  --writer X
        /// </summary>
        private string mWriter;

        /// <summary>
        /// Set year to X  --year X
        /// </summary>
        private int mYear = int.MinValue;

        #endregion

        /// <summary>
        /// Gets or sets the input files.
        /// </summary>
        /// <value>The input files.</value>
        public string[] InputFiles
        {
            get
            {
                if (mInfiles == null)
                    return new string[] {};
                return mInfiles;
            }
            set { mInfiles = value; }
        }

        /// <summary>
        /// Quantinizer Quality -q [quality]
        /// </summary>
        public int QuantinizerQuality
        {
            get { return mQuantinizerQuality; }
            set { mQuantinizerQuality = value; }
        }

        /// <summary>
        /// BitRate -b [bitrate]
        /// </summary>
        public int Bitrate
        {
            get { return mBitrate; }
            set { mBitrate = value; }
        }

        /// <summary>
        /// The bandwidth in Hz -c [freq]
        /// </summary>
        public SampleRateFrequency Bandwidth
        {
            get { return mBandwidth; }
            set { mBandwidth = value; }
        }

        /// <summary>
        /// The output filename (only for one input file) -o [filename]
        /// </summary>
        public string OutputFilename
        {
            get { return mOutputFilename; }
            set { mOutputFilename = value; }
        }

        /// <summary>
        /// Use RAW AAC output file -r
        /// </summary>
        public bool RawAACOutputFile { get; set; }

        /// <summary>
        /// Raw PCM input mode (default 44100Hz 16bit stereo) -P
        /// </summary>
        public bool RawPCMInputMode
        {
            get { return mRawPCMInputMode; }
            set { mRawPCMInputMode = value; }
        }

        /// <summary>
        /// Raw PCMInputSampleSize -R
        /// </summary>
        public SampleRateFrequency RawPCMInputSampleSize
        {
            get { return mRawPCMInputSampleSize; }
            set
            {
                mRawPCMInputSampleSize = value;
                RawPCMInputMode = true;
            }
        }

        /// <summary>
        /// Raw PCM input rate (default 16) -B
        /// </summary>
        public int RawPCMInputSampleRate
        {
            get { return mRawPCMInputSampleRate; }
            set
            {
                mRawPCMInputSampleRate = value;
                RawPCMInputMode = true;
            }
        }

        /// <summary>
        /// Raw PCM input channels -C
        /// </summary>
        public ChannelMode RawInputChannels
        {
            get { return mRawInputChannels; }
            set
            {
                mRawInputChannels = value;
                RawPCMInputMode = true;
            }
        }

        /// <summary>
        /// Raw PCM swap input bytes -X
        /// </summary>
        public bool RawPCMSwapInputBytes
        {
            get { return mRawPCMSwapInputBytes; }
            set
            {
                mRawPCMSwapInputBytes = value;
                RawPCMInputMode = true;
            }
        }

        /// <summary>
        /// Wrap AAC data in MP4 container. (default for *.mp4 and *.m4a)
        /// </summary>
        public bool WrapAACDataInMp4
        {
            get { return mWrapAACDataInMp4; }
            set { mWrapAACDataInMp4 = value; }
        }

        /// <summary>
        /// Set artist to X
        /// </summary>
        public string Artist
        {
            get { return mArtist; }
            set
            {
                mArtist = value;
                if (!string.IsNullOrEmpty(value))
                    WrapAACDataInMp4 = true;
            }
        }

        /// <summary>
        /// Set writer to X
        /// </summary>
        public string Writer
        {
            get { return mWriter; }
            set
            {
                mWriter = value;
                if (!string.IsNullOrEmpty(value))
                    WrapAACDataInMp4 = true;
            }
        }

        /// <summary>
        /// Set title to X
        /// </summary>
        public string Title
        {
            get { return mTitle; }
            set
            {
                mTitle = value;
                if (!string.IsNullOrEmpty(value))
                    WrapAACDataInMp4 = true;
            }
        }

        /// <summary>
        /// Set genre to X
        /// </summary>
        public string Genre
        {
            get { return mGenre; }
            set
            {
                mGenre = value;
                if (!string.IsNullOrEmpty(value))
                    WrapAACDataInMp4 = true;
            }
        }

        /// <summary>
        /// Set album to X
        /// </summary>
        public string Album
        {
            get { return mAlbum; }
            set
            {
                mAlbum = value;
                if (!string.IsNullOrEmpty(value))
                    WrapAACDataInMp4 = true;
            }
        }

        /// <summary>
        /// Set compilation
        /// </summary>
        public string Compilation
        {
            get { return mCompilation; }
            set
            {
                mCompilation = value;
                if (!string.IsNullOrEmpty(value))
                    WrapAACDataInMp4 = true;
            }
        }

        /// <summary>
        /// Set track to X (number/total)
        /// </summary>
        public string Track
        {
            get { return mTrack; }
            set
            {
                mTrack = value;
                if (!string.IsNullOrEmpty(value))
                    WrapAACDataInMp4 = true;
            }
        }

        /// <summary>
        /// Set disc to X (number/total)
        /// </summary>
        public string Disc
        {
            get { return mDisc; }
            set
            {
                mDisc = value;
                if (!string.IsNullOrEmpty(value))
                    WrapAACDataInMp4 = true;
            }
        }

        /// <summary>
        /// Set year to X
        /// </summary>
        public int Year
        {
            get { return mYear; }
            set
            {
                mYear = value;
                if (value != int.MinValue)
                    WrapAACDataInMp4 = true;
            }
        }

        /// <summary>
        /// Load cover art from filename
        /// </summary>
        public string CoverArtFilename
        {
            get { return mCoverArtFilename; }
            set
            {
                mCoverArtFilename = value;
                if (!string.IsNullOrEmpty(value))
                    WrapAACDataInMp4 = true;
            }
        }

        /// <summary>
        /// Quantinizer Quality -q [quality]
        /// </summary>
        public string Comment
        {
            get { return mComment; }
            set
            {
                mComment = value;
                if (!string.IsNullOrEmpty(value))
                    WrapAACDataInMp4 = true;
            }
        }

        /// <summary>
        /// Gets a string representing the command line arguments specified by the properties in the object.
        /// </summary>
        /// <returns></returns>
        public override string GetCommandLineArguments()
        {
            var stringBuilder = new StringBuilder();
            if (mQuantinizerQuality != int.MinValue)
                stringBuilder.Append(" -q " + mQuantinizerQuality);
            if (mBitrate != int.MinValue)
                stringBuilder.Append(" -b " + mBitrate);
            if (mBandwidth != SampleRateFrequency.Hz_0)
                stringBuilder.Append(" -c " + SampleRateFrequencyUtility.GetSampleRateFrequencyInt(mBandwidth));

            if (!string.IsNullOrEmpty(mOutputFilename))
            {
                if (mOutputFilename.Trim() == "-")
                    stringBuilder.Append(" -o-");
                else
                    stringBuilder.Append(" -o " + GetQuotedCommandLineArgument(mOutputFilename));
            }
            else
                stringBuilder.Append(" -o-");

            if (mRawPCMInputMode)
            {
                stringBuilder.Append(" -P ");
                if (mRawPCMInputSampleSize != SampleRateFrequency.Hz_44100)
                    stringBuilder.Append(" -R " +
                                         SampleRateFrequencyUtility.GetSampleRateFrequencyInt(mRawPCMInputSampleSize));
                if (mRawPCMInputSampleRate != 16)
                    stringBuilder.Append(" -B " + mRawPCMInputSampleRate);
                int chanelMode = ChannelModeUtility.GetChannelModeInt(mRawInputChannels);
                if (chanelMode != 2)
                    stringBuilder.Append(" -C " + chanelMode);
                if (mRawPCMSwapInputBytes)
                    stringBuilder.Append(" -X ");
            }

            if (mWrapAACDataInMp4)
            {
                stringBuilder.Append(" -w ");
                if (!string.IsNullOrEmpty(mArtist))
                    stringBuilder.Append(" --artist " + mArtist);
                if (!string.IsNullOrEmpty(mWriter))
                    stringBuilder.Append(" --writer " + mWriter);
                if (!string.IsNullOrEmpty(mTitle))
                    stringBuilder.Append(" --title " + mTitle);
                if (!string.IsNullOrEmpty(mGenre))
                    stringBuilder.Append(" --genre " + mGenre);
                if (!string.IsNullOrEmpty(mAlbum))
                    stringBuilder.Append(" --album " + mAlbum);
                if (!string.IsNullOrEmpty(mCompilation))
                    stringBuilder.Append(" --compilation " + mCompilation);
                if (!string.IsNullOrEmpty(mTrack))
                    stringBuilder.Append(" --track " + mTrack);
                if (!string.IsNullOrEmpty(mDisc))
                    stringBuilder.Append(" --disc " + mDisc);
                if (mYear != int.MinValue)
                    stringBuilder.Append(" --year " + mYear);
                if (!string.IsNullOrEmpty(mCoverArtFilename))
                    stringBuilder.Append(" --cover-art " + mCoverArtFilename);
                if (!string.IsNullOrEmpty(mComment))
                    stringBuilder.Append(" --comment " + mComment);
            }
            if (mInfiles != null && mInfiles.Length > 0)
            {
                // use standard input
                if (mInfiles[0].Trim() == "-")
                    stringBuilder.Append(" -");
                else
                {
                    foreach (string infile in mInfiles)
                        stringBuilder.Append(" " + GetQuotedCommandLineArgument(infile));
                }
            }
            else
                stringBuilder.Append(" -");


            return stringBuilder.ToString();
        }
    }
}