/****************************************************************************
**
** Copyright (C) 2019 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the Qt VS Tools.
**
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace QtVsTools.SyntaxAnalysis
{
    using static CharClass;

    public abstract partial class RegExpr
    {
        /// <summary><![CDATA[
        /// Equivalent to: [\w]
        /// ]]></summary>
        public static CharClassLiteral CharWord
        { get { return new CharClassLiteral { LiteralChars = @"\w" }; } }

        /// <summary><![CDATA[
        /// Equivalent to: [\w]*
        /// ]]></summary>
        public static RegExpr Word
        { get { return CharWord.Repeat(); } }

        /// <summary><![CDATA[
        /// Equivalent to: [\d]
        /// ]]></summary>
        public static CharClassLiteral CharDigit
        { get { return new CharClassLiteral { LiteralChars = @"\d" }; } }

        /// <summary><![CDATA[
        /// Equivalent to: [\d]*
        /// ]]></summary>
        public static RegExpr Number
        { get { return CharDigit.Repeat(); } }

        /// <summary><![CDATA[
        /// Equivalent to: [\r]
        /// ]]></summary>
        public static CharClassLiteral CharCr
        { get { return new CharClassLiteral { LiteralChars = @"\r" }; } }

        /// <summary><![CDATA[
        /// Equivalent to: [\n]
        /// ]]></summary>
        public static CharClassLiteral CharLf
        { get { return new CharClassLiteral { LiteralChars = @"\n" }; } }

        /// <summary><![CDATA[
        /// Equivalent to: [\s]
        /// ]]></summary>
        public static CharClassLiteral CharSpace
        { get { return new CharClassLiteral { LiteralChars = @"\s" }; } }

        /// <summary><![CDATA[
        /// Equivalent to: [\S]
        /// ]]></summary>
        public static CharClassLiteral CharNonSpace
        { get { return new CharClassLiteral { LiteralChars = @"\S" }; } }

        /// <summary><![CDATA[
        /// Equivalent to: [\r\n]
        /// ]]></summary>
        public static CharClassSet CharVertSpace
        { get { return CharSet[CharCr + CharLf]; } }

        /// <summary><![CDATA[
        /// Equivalent to: [^\S\r\n]
        /// ]]></summary>
        public static CharClassSet CharHorizSpace
        { get { return CharSet[~(CharNonSpace + CharVertSpace)]; } }

        /// <summary><![CDATA[
        /// Equivalent to: .
        /// ]]></summary>
        public static RegExprLiteral AnyChar
        { get { return new RegExprLiteral { LiteralExpr = "." }; } }

        /// <summary><![CDATA[
        /// Equivalent to: ^
        /// ]]></summary>
        public static RegExprLiteral StartOfLine
        { get { return new RegExprLiteral { LiteralExpr = "^" }; } }

        /// <summary><![CDATA[
        /// Equivalent to: $
        /// ]]></summary>
        public static RegExprLiteral EndOfLine
        { get { return new RegExprLiteral { LiteralExpr = "$" }; } }

        /// <summary><![CDATA[
        /// Equivalent to: \A
        /// ]]></summary>
        public static RegExprLiteral StartOfFile
        { get { return new RegExprLiteral { LiteralExpr = @"\A" }; } }

        /// <summary><![CDATA[
        /// Equivalent to: \z
        /// ]]></summary>
        public static RegExprLiteral EndOfFile
        { get { return new RegExprLiteral { LiteralExpr = @"\z" }; } }

        /// <summary><![CDATA[
        /// Equivalent to: \r?\n
        /// ]]></summary>
        public static RegExprSequence LineBreak
        { get { return CharCr.Optional() & CharLf; } }

        /// <summary><![CDATA[
        /// Equivalent to: [\s]*
        /// ]]></summary>
        public static RegExpr Space
        { get { return CharSpace.Repeat(); } }

        /// <summary><![CDATA[
        /// Equivalent to: [\S]*
        /// ]]></summary>
        public static RegExpr NonSpace
        { get { return CharNonSpace.Repeat(); } }

        /// <summary><![CDATA[
        /// Equivalent to: [\r\n]*
        /// ]]></summary>
        public static RegExpr VertSpace
        { get { return CharVertSpace.Repeat(); } }

        /// <summary><![CDATA[
        /// Equivalent to: [^\S\r\n]*
        /// ]]></summary>
        public static RegExpr HorizSpace
        { get { return CharHorizSpace.Repeat(); } }

        /// <summary><![CDATA[
        /// Equivalent to: [^\r\n]*
        /// ]]></summary>
        public static RegExpr Line
        { get { return CharSet[~CharVertSpace].Repeat(); } }

        /// <summary><![CDATA[
        /// Equivalent to: (?i)
        /// ]]></summary>
        public static RegExprLiteral IgnoreCase
        { get { return new RegExprLiteral { LiteralExpr = @"(?i)" }; } }

        /// <summary><![CDATA[
        /// Equivalent to: (?-i)
        /// ]]></summary>
        public static RegExprLiteral SenseCase
        { get { return new RegExprLiteral { LiteralExpr = @"(?-i)" }; } }

        /// <summary>
        /// Applies the same whitespace skipping rules as tokens, but does not any capture text.
        /// </summary>
        public static RegExpr SkipWs
        { get { return new Token(); } }

        static CharExprBuilder _Char = new CharExprBuilder();
        public static CharExprBuilder Char { get { return _Char; } }
        public static CharExprBuilder Chars { get { return _Char; } }

        static CharSetExprBuilder _CharSet = new CharSetExprBuilder();
        public static CharSetExprBuilder CharSet { get { return _CharSet; } }

        static CharSetRawExprBuilder _CharSetRaw = new CharSetRawExprBuilder();
        public static CharSetRawExprBuilder CharSetRaw { get { return _CharSetRaw; } }

        static AssertExprBuilder _LookAhead = new AssertExprBuilder(AssertLookAhead);
        public static AssertExprBuilder LookAhead { get { return _LookAhead; } }

        static AssertExprBuilder _LookBehind = new AssertExprBuilder(AssertLookBehind);
        public static AssertExprBuilder LookBehind { get { return _LookBehind; } }

        public const SkipWhitespace SkipWs_Disable = SkipWhitespace.Disable;
    }
}