namespace Siderite.Text.RegularExpressions
{
/// <summary>
/// Regex Match equivalent for Streams
/// </summary>
public class StreamMatch
{
private readonly Match _match;
private readonly StreamRegex _streamRegex;
private long _streamIndex;

/// <summary>
/// Constructor
/// </summary>
/// <param name="regex">StreamRegex that generated it</param>
/// <param name="m">internal Regex match</param>
/// <param name="streamIndex">real stream index</param>
internal StreamMatch(StreamRegex regex, Match m, long streamIndex)
{
_streamRegex = regex;
_match = m;
StreamIndex = streamIndex;
}

/// <summary>
/// Empty StreamMatch
/// </summary>
public static StreamMatch Empty
{
get { return new StreamMatch(null, null,0); }
}

/// <summary>
/// Success of matching
/// </summary>
public bool Success
{
get
{
if (_match == null) return false;
// matches with length 0 would only cause infinite loops
if ((_streamRegex.EmptyRegexMode==EmptyRegexMode.NoSuccess)&&(_match.Length == 0)) 
return false;
return _match.Success;
}
}

/// <summary>
/// Length of match
/// </summary>
public int Length
{
get
{
if (_match == null) return 0;
return _match.Length;
}
}

/// <summary>
/// Groups in the match. This is a regular Regex GroupCollection
/// </summary>
public GroupCollection Groups
{
get
{
if (_match == null) return null;
return _match.Groups;
}
}

/// <summary>
/// Value of the match
/// </summary>
public string Value
{
get
{
if (_match == null) return null;
return _match.Value;
}
}

/// <summary>
/// Group names in the match including "0","1", etc
/// </summary>
public string[] GroupNames
{
get
{
if (_streamRegex == null) return null;
return _streamRegex.GroupNames;
}
}

/// <summary>
/// Group names in the match that are non numeric (words only)
/// </summary>
public IEnumerable<string> NonNumericGroupNames
{
get
{
if (_streamRegex == null) return null;
return _streamRegex.NonNumericGroupNames;
}
}

public long StreamIndex
{
get { return _streamIndex; }
set { _streamIndex = value; }
}

/// <summary>
/// indexer using a name
/// </summary>
/// <param name="groupName"></param>
/// <returns>Regular Regex Group. The group Index has no meaning</returns>
public Group this[string groupName]
{
get
{
if (_match == null) return null;
return _match.Groups[groupName];
}
}

/// <summary>
/// indexer using a numeric index
/// </summary>
/// <param name="groupNr"></param>
/// <returns>Regular Regex Group. The group Index has no meaning</returns>
public Group this[int groupNr]
{
get
{
if (_match == null) return null;
return _match.Groups[groupNr];
}
}

/// <summary>
/// Find next match
/// </summary>
/// <returns></returns>
public StreamMatch NextMatch()
{
if (_streamRegex == null) return null;
return _streamRegex.NextMatch();
}
}

public enum EmptyRegexMode
{
NoSuccess,
ThrowException,
Success
}

/// <summary>
/// Regex equivalent for Streams
/// </summary>
public class StreamRegex
{
private readonly Regex _regex;
private readonly StringBuilder _sb;
private readonly Stream _stream;
private byte[] _buffer;
private int _bufferSize = 65536;
private long _currentPosition;
private Encoding _encoding;
private string[] _groupNames;
private long _internalStreamLength;
private bool _matchInitialised;
private long _maxMatchLength;
private EmptyRegexMode _emptyRegexMode;

/// <summary>
/// Constructor
/// </summary>
/// <param name="stream">Any readable stream.</param>
/// <param name="pattern">A regex pattern</param>
public StreamRegex(Stream stream, string pattern)
: this(stream, pattern, RegexOptions.IgnoreCase | RegexOptions.Singleline| RegexOptions.Compiled)
{
}

/// <summary>
/// Constructor
/// </summary>
/// <param name="stream">Any readable stream.</param>
/// <param name="pattern">A regex pattern</param>
/// <param name="regexOptions">Regex options to be used</param>
public StreamRegex(Stream stream, string pattern, RegexOptions regexOptions)
: this(stream, pattern, regexOptions, Encoding.GetEncoding(1252))
{
}

/// <summary>
/// Constructor
/// </summary>
/// <param name="stream">Any readable stream.</param>
/// <param name="pattern">A regex pattern</param>
/// <param name="regexOptions">Regex options to be used</param>
/// <param name="encoding">Encoding of the stream</param>
public StreamRegex(Stream stream, string pattern, RegexOptions regexOptions, Encoding encoding)
: this(stream, pattern, regexOptions, encoding, long.MaxValue/2)
{
}

/// <summary>
/// Constructor
/// </summary>
/// <param name="stream">Any readable stream.</param>
/// <param name="pattern">A regex pattern</param>
/// <param name="regexOptions">Regex options to be used</param>
/// <param name="encoding">Encoding of the stream</param>
/// <param name="maxMatchLength">Maximum possible match. Specify this to minimize memory use</param>
public StreamRegex(Stream stream, string pattern, RegexOptions regexOptions, Encoding encoding,
long maxMatchLength)
{
_regex = new Regex(pattern, regexOptions);
_stream = stream;
_matchInitialised = false;
Encoding = encoding;
MaxMatchLength = maxMatchLength;
_sb = new StringBuilder();
EmptyRegexMode = EmptyRegexMode.NoSuccess;
}

/// <summary>
/// Read buffer size. default 65536 bytes
/// Warning: this works on an internal string that will be 
/// a multiple of this number. Don't make it too large.
/// </summary>
public int BufferSize
{
get { return _bufferSize; }
set
{
_bufferSize = value;
// you cannot run NextMatch now
_matchInitialised = false;
}
}

/// <summary>
/// Encoding for the stream. default Windows-1252
/// </summary>
public Encoding Encoding
{
get { return _encoding; }
set { _encoding = value; }
}

/// <summary>
/// Maximum possible match length. default long.MaxValue/2
/// </summary>
public long MaxMatchLength
{
get { return _maxMatchLength; }
set { _maxMatchLength = value; }
}

/// <summary>
/// Names of the groups in the regex expression
/// </summary>
public string[] GroupNames
{
get
{
if (_regex == null) return null;
if (_groupNames == null)
{
_groupNames = _regex.GetGroupNames();
}
return _groupNames;
}
}

/// <summary>
/// Names of the groups in the regex expression
/// that are non numeric (so only the word names)
/// </summary>
public IEnumerable<string> NonNumericGroupNames
{
get
{
if (_regex == null) return null;
List<string> list = new List<string>();
foreach (string groupName in _regex.GetGroupNames())
{
if (!Regex.IsMatch(groupName, @"^\d+$")) list.Add(groupName);
}
return list;
}
}

/// <summary>
/// defines who empty matches are treated: 
/// no success match, exception or succesful match
/// defaults to no success match
/// </summary>
public EmptyRegexMode EmptyRegexMode
{
get { return _emptyRegexMode; }
set { _emptyRegexMode = value; }
}

/// <summary>
/// Match the pattern on the stream, starting with current position
/// </summary>
/// <returns></returns>
public StreamMatch Match()
{
return Match(0L);
}

/// <summary>
/// Match the pattern on the stream, starting with current position
/// </summary>
/// <param name="index">skip index bytes</param>
/// <returns></returns>
public StreamMatch Match(long index)
{
return Match(index, long.MaxValue/2);
}

/// <summary>
/// Match the pattern on the stream, starting with current position
/// </summary>
/// <param name="index">skip index bytes</param>
/// <param name="length">read no more than length bytes</param>
/// <returns></returns>
public StreamMatch Match(long index, long length)
{
if (!_stream.CanRead) throw new Exception("Stream is not readable");
if (length <= 0) return StreamMatch.Empty;
if (index != 0) SeekStream(index);
_buffer = new byte[BufferSize];
_sb.Length = 0;
// initialize real position in stream
_currentPosition = _stream.Position;
// this is the maximum length of bytes this match will read
_internalStreamLength = length;
// you can now call NextMatch
_matchInitialised = true;
return NextMatch();
}

internal StreamMatch NextMatch()
{
if (!_matchInitialised) 
throw new Exception("First run Match, then NextMatch");
// search the buffer string first
Match m = _regex.Match(_sb.ToString());
if (m.Success&&((EmptyRegexMode!=EmptyRegexMode.NoSuccess)||(m.Length>0)))
{
if (EmptyRegexMode == EmptyRegexMode.ThrowException)
{
if (m.Length == 0)
throw new Exception(
"Successful Match has empty value. If you use NextMatch in a loop it will become infinite");
}
StreamMatch sm = new StreamMatch(this, m, _currentPosition + m.Index);

//remove matches to minimize memory usage
int extra = m.Index + m.Length;
_sb.Remove(0, extra);
// update real position in stream
_currentPosition += extra;

return sm;
}
int l;
while ((l = _stream.Read(_buffer, 0, (int) Math.Min(_internalStreamLength, _buffer.Length))) > 0)
{
_internalStreamLength -= l;

// remove part of StringBuilder where there is no chance it contains a match
// this works only if MaxMatch is specified
long extraLength = _sb.Length - MaxMatchLength;
if (extraLength > 0)
{
_sb.Remove(0, (int) extraLength);
_currentPosition += extraLength;
}


_sb.Append(Encoding.GetString(_buffer, 0, l));

// TODO: remove this
Debug.WriteLine("SB length: " + _sb.Length);

m = _regex.Match(_sb.ToString());
if (m.Success)
{
StreamMatch sm = new StreamMatch(this, m, _currentPosition + m.Index);

//remove matches to minimize memory usage
int extra = m.Index + m.Length;
_sb.Remove(0, extra);
// update real position in stream
_currentPosition += extra;
return sm;
}
}
return new StreamMatch(this, m, 0);
}

/// <summary>
/// Get all matches from the stream
/// </summary>
/// <returns></returns>
public IEnumerable<StreamMatch> Matches()
{
return Matches(0L);
}

/// <summary>
/// Get all matches from the stream
/// </summary>
/// <param name="index">skip index bytes</param>
/// <returns></returns>
public IEnumerable<StreamMatch> Matches(long index)
{
return Matches(index, long.MaxValue/2);
}

/// <summary>
/// Get all matches from the stream
/// </summary>
/// <param name="index">skip index bytes</param>
/// <param name="length">read no more than length bytes</param>
/// <returns></returns>
public IEnumerable<StreamMatch> Matches(long index, long length)
{
List<StreamMatch> list = new List<StreamMatch>();
StreamMatch m = Match(index, length);
while (m.Success)
{
list.Add(m);
m = NextMatch();
}
return list;
}

/// <summary>
/// Seek the stream to specified position
/// </summary>
/// <param name="index">seek to index from current position</param>
public void SeekStream(long index)
{
SeekStream(index, SeekOrigin.Current);
}

/// <summary>
/// Seek the stream to specified position
/// </summary>
/// <param name="index">seek to index position</param>
/// <param name="origin">from current position, start or end</param>
public void SeekStream(long index, SeekOrigin origin)
{
int _tmpSeekSize = 65536;
if (_stream.CanSeek)
{
_stream.Seek(index, origin);
}
else
{
if (origin != SeekOrigin.Current) throw new Exception("Stream is not seakable");
long l = 0;
try
{
l = _stream.Length;
}
#pragma warning disable EmptyGeneralCatchClause
catch (Exception)
{
}
#pragma warning restore EmptyGeneralCatchClause
if ((l > 0) && (l < 65536)) _tmpSeekSize = 4096;
if (l > 1000000) _tmpSeekSize = 409600;
if (index >= 0)
{
byte[] buff = new byte[_tmpSeekSize];
l = index;
while (l > 0)
{
l -= _stream.Read(buff, 0, (int) Math.Min(l, buff.Length));
}
}
else
{
throw new Exception("begin cannot be negative on a non seeking stream");
}
}

// update real position in stream
_currentPosition = _stream.Position;
// you cannot run NextMatch now
_matchInitialised = false;
}
}
}

using System;
using System.Data.SqlTypes;

namespace Siderite.Util
{
    ///<summary>
    /// Wraps a nullable type so that it can be passed as a method parameter
    ///</summary>
    [Serializable]
    public class NullableWrapper
    {
        private Type _underlyingType;
        private object _wrappedValue;

        private NullableWrapper()
        {
        }

        ///<summary>
        /// The underlying type in the nullable type
        ///</summary>
        public Type UnderlyingType
        {
            get { return _underlyingType; }
            set { _underlyingType = value; }
        }

        ///<summary>
        /// The value inside the nullable type
        ///</summary>
        public object WrappedValue
        {
            get { return _wrappedValue; }
            set { _wrappedValue = value; }
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<Byte> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (Byte);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<Int16> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (Int16);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<Int32> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (Int32);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<Int64> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (Int64);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<UInt16> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (UInt16);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<UInt32> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (UInt32);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<UInt64> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (UInt64);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<Single> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (Single);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<Double> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (Double);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<Decimal> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (Decimal);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<Boolean> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (Boolean);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<Char> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (Char);
            nw.WrappedValue = obj ?? null;
            return nw;
        }


        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<IntPtr> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (IntPtr);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Conversion implicit operator
        ///</summary>
        ///<param name="obj"></param>
        ///<returns></returns>
        public static implicit operator
            NullableWrapper(Nullable<UIntPtr> obj)
        {
            NullableWrapper nw = new NullableWrapper();
            nw.UnderlyingType = typeof (UIntPtr);
            nw.WrappedValue = obj ?? null;
            return nw;
        }

        ///<summary>
        /// Return the Sql Server typed value from the wrapped nullable type
        ///</summary>
        ///<returns></returns>
        ///<exception cref="Exception"></exception>
        public object GetSqlValue()
        {
            if (UnderlyingType == null) return DBNull.Value;
            switch (UnderlyingType.FullName)
            {
                case "System.Byte":
                    return WrappedValue == null
                               ? SqlByte.Null
                               : new SqlByte((byte) WrappedValue);
                case "System.SByte":
                    return WrappedValue == null
                               ? SqlInt16.Null
                               : new SqlInt16((sbyte) WrappedValue);
                case "System.Int16":
                    return WrappedValue == null
                               ? SqlInt16.Null
                               : new SqlInt16((Int16) WrappedValue);
                case "System.Int32":
                    return WrappedValue == null
                               ? SqlInt32.Null
                               : new SqlInt32((Int32) WrappedValue);
                case "System.Int64":
                    return WrappedValue == null
                               ? SqlInt64.Null
                               : new SqlInt64((Int64) WrappedValue);
                case "System.UInt16":
                    return WrappedValue == null
                               ? SqlInt32.Null
                               : new SqlInt32((UInt16) WrappedValue);
                case "System.UInt32":
                    return WrappedValue == null
                               ? SqlInt64.Null
                               : new SqlInt64((UInt32) WrappedValue);
                case "System.UInt64":
                    return WrappedValue == null
                               ? SqlInt64.Null
                               : new SqlInt64(((Int64) WrappedValue));
                case "System.Single":
                    return WrappedValue == null
                               ? SqlSingle.Null
                               : new SqlSingle(((Single) WrappedValue));
                case "System.Double":
                    return WrappedValue == null
                               ? SqlDouble.Null
                               : new SqlDouble(((Double) WrappedValue));
                case "System.Decimal":
                    return WrappedValue == null
                               ? SqlDecimal.Null
                               : new SqlDecimal(((Decimal) WrappedValue));
                case "System.Boolean":
                    return WrappedValue == null
                               ? SqlBoolean.Null
                               : new SqlBoolean(((Boolean) WrappedValue));
                case "System.Char":
                    return WrappedValue == null
                               ? SqlString.Null
                               : new SqlString(((Char) WrappedValue).ToString());
                case "System.String":
                    return WrappedValue == null
                               ? SqlString.Null
                               : new SqlString(((String) WrappedValue));
                default:
                    throw new Exception("Unsupported type " 
                        + UnderlyingType.FullName);
            }
        }
    }
}