using System;
using System.IO;

namespace SharpCifs.Util.Sharpen
{
    public class OutputStream : IDisposable
	{
		protected Stream Wrapped;

		public static implicit operator OutputStream (Stream s)
		{
			return Wrap (s);
		}

		public static implicit operator Stream (OutputStream s)
		{
			return s.GetWrappedStream ();
		}
		
		public virtual void Close ()
		{
			if (Wrapped != null) {
                //Stream.`Close` method deleted
                //Wrapped.Close ();
                Wrapped.Dispose();
            }
		}

		public void Dispose ()
		{
			Close ();           
		}

		public virtual void Flush ()
		{
			if (Wrapped != null) {
				Wrapped.Flush ();
			}
		}

		internal Stream GetWrappedStream ()
		{
			// Always create a wrapper stream (not directly Wrapped) since the subclass
			// may be overriding methods that need to be called when used through the Stream class
			return new WrappedSystemStream (this);
		}

		static internal OutputStream Wrap (Stream s)
		{
			OutputStream stream = new OutputStream ();
			stream.Wrapped = s;
			return stream;
		}

		public virtual void Write (int b)
		{
			if (Wrapped is WrappedSystemStream)
				((WrappedSystemStream)Wrapped).OutputStream.Write (b);
			else {
				if (Wrapped == null)
					throw new NotImplementedException ();
				Wrapped.WriteByte ((byte)b);
			}
		}

		public virtual void Write (byte[] b)
		{
			Write (b, 0, b.Length);
		}

		public virtual void Write (byte[] b, int offset, int len)
		{
			if (Wrapped is WrappedSystemStream)
				((WrappedSystemStream)Wrapped).OutputStream.Write (b, offset, len);
			else {
				if (Wrapped != null) {
					Wrapped.Write (b, offset, len);
				} else {
					for (int i = 0; i < len; i++) {
						Write (b[i + offset]);
					}
				}
			}
		}
	}
}