/* 
 * Reference arithmetic coding
 * Copyright (c) Project Nayuki
 * 
 * https://www.nayuki.io/page/reference-arithmetic-coding
 * https://github.com/nayuki/Reference-arithmetic-coding
 */



using System;
/// <summary>
/// Encodes symbols and writes to an arithmetic-coded bit stream. Not thread-safe. </summary>
/// <seealso cref= ArithmeticDecoder </seealso>
public sealed class ArithmeticEncoder : ArithmeticCoderBase
{

	/*---- Fields ----*/

	// The underlying bit output stream (not null).
	private BitOutputStream output;

	// Number of saved underflow bits. This value can grow without bound,
	// so a truly correct implementation would use a BigInteger.
	private int numUnderflow;



	/*---- Constructor ----*/

	/// <summary>
	/// Constructs an arithmetic coding encoder based on the specified bit output stream. </summary>
	/// <param name="numBits"> the number of bits for the arithmetic coding range </param>
	/// <param name="out"> the bit output stream to write to </param>
	/// <exception cref="NullPointerException"> if the output stream is {@code null} </exception>
	/// <exception cref="IllegalArgumentException"> if stateSize is outside the range [1, 62] </exception>
	public ArithmeticEncoder(int numBits, BitOutputStream @out) : base(numBits)
	{
		output = @out; //Objects.requireNonNull(@out);
		numUnderflow = 0;
	}



	/*---- Methods ----*/

	/// <summary>
	/// Encodes the specified symbol based on the specified frequency table.
	/// This updates this arithmetic coder's state and may write out some bits. </summary>
	/// <param name="freqs"> the frequency table to use </param>
	/// <param name="symbol"> the symbol to encode </param>
	/// <exception cref="NullPointerException"> if the frequency table is {@code null} </exception>
	/// <exception cref="IllegalArgumentException"> if the symbol has zero frequency
	/// or the frequency table's total is too large </exception>
	/// <exception cref="IOException"> if an I/O exception occurred </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public void write(FrequencyTable freqs, int symbol) throws java.io.IOException
	public void write(FrequencyTable freqs, int symbol)
	{
		write(new CheckedFrequencyTable(freqs), symbol);
	}


	/// <summary>
	/// Encodes the specified symbol based on the specified frequency table.
	/// Also updates this arithmetic coder's state and may write out some bits. </summary>
	/// <param name="freqs"> the frequency table to use </param>
	/// <param name="symbol"> the symbol to encode </param>
	/// <exception cref="NullPointerException"> if the frequency table is {@code null} </exception>
	/// <exception cref="IllegalArgumentException"> if the symbol has zero frequency
	/// or the frequency table's total is too large </exception>
	/// <exception cref="IOException"> if an I/O exception occurred </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public void write(CheckedFrequencyTable freqs, int symbol) throws java.io.IOException
	public void write(CheckedFrequencyTable freqs, int symbol)
	{
		update(freqs, symbol);
	}


	/// <summary>
	/// Terminates the arithmetic coding by flushing any buffered bits, so that the output can be decoded properly.
	/// It is important that this method must be called at the end of the each encoding process.
	/// <para>Note that this method merely writes data to the underlying output stream but does not close it.</para> </summary>
	/// <exception cref="IOException"> if an I/O exception occurred </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public void finish() throws java.io.IOException
	public void finish()
	{
		output.write(1);
	}


//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: protected void shift() throws java.io.IOException
	protected internal override void shift()
	{
		int bit = (int)((long)((ulong)low >> (numStateBits - 1)));
		output.write(bit);

		// Write out the saved underflow bits
		for (; numUnderflow > 0; numUnderflow--)
		{
			output.write(bit ^ 1);
		}
	}


	protected internal override void underflow()
	{
		if (numUnderflow == int.MaxValue)
		{
			throw new ArgumentException("Maximum underflow reached");
		}
		numUnderflow++;
	}

}