/*
  * Copyright (c) 2017 by Fenrir Inc., All rights reserved.
  *
  * Use of the source code and binary libraries included in this package
  * is permitted under the following terms:
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

package com.fenrir_inc.example.devblog;

import android.text.TextUtils;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class URIRegExpGenerator {
    static abstract class Expression {
        protected String abnfDisplayName() {
            return null;
        } 
        public abstract String regexp(); 
        public abstract String abnf(); 
    }

    static abstract class RepeatExpression extends Expression {
        private Expression mExpression;
        public RepeatExpression( Expression expression ) {
            mExpression = expression;
        }
        protected abstract String regexpRepeat(); 
        protected abstract String abnfRepeat(); 
        
        @Override
        public String regexp() {
            return mExpression.regexp() + regexpRepeat();
        } 

        @Override
        public String abnf() {
            String s = mExpression.abnfDisplayName();
            if ( TextUtils.isEmpty(s)) {
                s = mExpression.abnf();
            }
            return abnfRepeat() + s;
        } 
    }

    static class RepeatExpressionAsterisc extends RepeatExpression {
        public RepeatExpressionAsterisc(Expression expression) {
            super(expression);
        }

        @Override
        protected String regexpRepeat() {
            return "*";
        }

        @Override
        protected String abnfRepeat() {
            return "*";
        }
    }

    static class RepeatExpressionCount extends RepeatExpression {
        
        private int mCount;

        public RepeatExpressionCount(Expression expression, int count) {
            super(expression);
            mCount = count;
        }

        @Override
        protected String regexpRepeat() {
            return String.format( "{%d}", mCount);
        }

        @Override
        protected String abnfRepeat() {
            return String.format( "%d", mCount);
        }
    }

    static class RepeatExpressionRange extends RepeatExpression {
        private int mFromValue;
        private int mToValue;

        public RepeatExpressionRange(Expression expression, int fromValue, int toValue) {
            super(expression);
            mFromValue = fromValue;
            mToValue = toValue;
        }

        @Override
        protected String regexpRepeat() {
            return String.format( "{%d,%d}", mFromValue, mToValue);
        }

        @Override
        protected String abnfRepeat() {
            return String.format( "%d*%d", mFromValue, mToValue);
        }
    }

    static class RepeatExpressionLess extends RepeatExpression {
        
        private int mLessValue;

        public RepeatExpressionLess(Expression expression, int lessValue) {
            super(expression);
            mLessValue = lessValue;
        }

        @Override
        protected String regexpRepeat() {
            return String.format( "{0,%d}", mLessValue);
        }

        @Override
        protected String abnfRepeat() {
            return String.format( "*%d", mLessValue);
        }
    }

    static class RepeatExpressionMore extends RepeatExpression {
        private int mMoreValue;

        public RepeatExpressionMore(Expression expression, int moreValue) {
            super(expression);
            mMoreValue = moreValue;
        }

        @Override
        protected String regexpRepeat() {
            return String.format( "{%d,}", mMoreValue);
        }

        @Override
        protected String abnfRepeat() {
            return String.format( "%d*", mMoreValue);
        }
    }

    static class OptionalExpression extends Expression {

        private Expression mExpression;
        
        public OptionalExpression( Expression expression ) {
            mExpression = expression;
        }

        @Override
        public String regexp() {
            return mExpression.regexp() + "?";
        }

        @Override
        public String abnf() {
            String s = mExpression.abnfDisplayName();
            if ( TextUtils.isEmpty(s) ) {
                s = mExpression.abnf();
            }
            return "[ " + s + " ]";
        }
    }

    static  class StringExpression extends Expression {
        protected String mExpression;
        public StringExpression(String expression) {
            mExpression = expression;
        }

        @Override
        public String abnf() {
            return quotedString( excludeBackSlash( mExpression ) );
        }

        @Override
        public String regexp() {
            return mExpression;
        }
    }

    abstract static class GroupedExpression extends Expression {

        private boolean mUseParen;
        public GroupedExpression( boolean useParen ) {
            mUseParen = useParen;
        }

        protected abstract Expression[] expressionList();
        protected abstract String regexpDelimiter();
        protected abstract String bnfDelimiter();

        protected boolean reverse() {
            return false;
        }

        @Override
        public String regexp() {
            Expression[] expressions = expressionList();
            StringBuilder sb = new StringBuilder();
            sb.append("(");
            
            List<Expression> list = Arrays.asList(expressions);
            if  ( reverse() ) {
                Collections.reverse( list );
            }
            Iterator<Expression> itr = list.iterator();
            while ( itr.hasNext() ) {
                Expression  exp = itr.next();
                sb.append( exp.regexp() );
                if ( itr.hasNext() ) {
                    sb.append( regexpDelimiter() );
                }
            }
            sb.append(")");
            return sb.toString();
        }

        @Override
        public String abnf() {
            StringBuilder sb = new StringBuilder();

            Expression[] expressions = expressionList();

            if ( mUseParen ) {
                sb.append( "( " );
            }
            for ( int i = 0; i < expressions.length; i++ ) {
                Expression exp = expressions[i];
                String s = exp.abnfDisplayName();
                if ( TextUtils.isEmpty(s) ) {
                    s = exp.abnf();
                }
                sb.append( s );
                if ( i < (expressions.length - 1)) {
                    sb.append( bnfDelimiter() );
                }
            }
            if ( mUseParen ) {
                sb.append(" )");
            }
            return sb.toString();
        } 
    }

    abstract static class GroupedExpressionConcat extends GroupedExpression {

        public GroupedExpressionConcat(boolean useParen) {
            super(useParen);
        }

        public GroupedExpressionConcat() {
            super(false);
        }

        @Override
        protected String regexpDelimiter() {
            return "";
        }

        @Override
        protected String bnfDelimiter() {
            return " ";
        }

    }

    abstract static class GroupedExpressionOr extends GroupedExpression {
        public GroupedExpressionOr(boolean useBnfParen) {
            super(useBnfParen);
        }

        public GroupedExpressionOr() {
            super(false);
        }

        @Override
        protected String regexpDelimiter() {
            return "|";
        }

        @Override
        protected String bnfDelimiter() {
            return " / ";
        }
    }

    static class URIExpression extends GroupedExpressionConcat {
        
        private String mScheme;
        
        public URIExpression( String scheme ) {
            super(false);
            mScheme = scheme;
        }

        public URIExpression() {
            super(false);
        }

        @Override
        protected Expression[] expressionList() {
            return new Expression[] {
                new SchemeExpression( mScheme ),
                new StringExpression("\\:"),
                new HierPartExpression(),
                new OptionalExpression(
                    new GroupedExpressionConcat() {
                        @Override
                        protected Expression[] expressionList() {
                            return new Expression[] {
                                new StringExpression("\\?"),
                                new QueryExpression()
                            };
                        }
                    }),
                new OptionalExpression(
                    new GroupedExpressionConcat() {
                        @Override
                        protected Expression[] expressionList() {
                            return new Expression[] {
                                new StringExpression("\\#"),
                                new FragmentExpression()
                            };
                        }
                    })
            };
        }

        @Override
        protected String abnfDisplayName() {
            return "URI";
        }
    }    

    static class HierPartExpression extends GroupedExpressionOr {
        @Override
        protected Expression[] expressionList() {
            return new Expression[] {
                new GroupedExpressionConcat() {
                    @Override
                    protected Expression[] expressionList() {
                        return new Expression[] {
                            new StringExpression("\\/\\/"),
                            new AuthorityExpression(),
                            new PathAbEmptyExpression()
                        };
                    }
                },
                new PathAbsoluteExpression(),
                new PathRootlessExpression(),
                new PathEmptyExpression()
            };
        }

        @Override
        protected String abnfDisplayName() {
            return "hier-part";
        }
    }

    static class URIReferenceExpression extends GroupedExpressionOr {
        @Override
        protected Expression[] expressionList() {
            return new Expression[] {
                new URIExpression(""),
                new RelativeRefExpression()
            };
        }

        @Override
        protected String abnfDisplayName() {
            return "URI-reference";
        }
    }

    static class AbsoluteURIExpression extends GroupedExpressionConcat {
        @Override
        protected Expression[] expressionList() {
            return new Expression[] {
                new SchemeExpression(""),
                new StringExpression("\\:"),
                new HierPartExpression(),
                new OptionalExpression(
                    new GroupedExpressionConcat() {
                        @Override
                        protected Expression[] expressionList() {
                            return new Expression[] {
                                new StringExpression("\\?"),
                                new QueryExpression()
                            };
                        }
                    })
            };
        }

        @Override
        protected String abnfDisplayName() {
            return "absolute-URI";
        }
    }    

    static class RelativeRefExpression extends GroupedExpressionConcat {
        @Override
        protected Expression[] expressionList() {
            return new Expression[] {
                new RelativePartExpression(),
                new OptionalExpression(
                    new GroupedExpressionConcat() {
                        @Override
                        protected Expression[] expressionList() {
                            return new Expression[] {
                                new StringExpression("\\?"),
                                new QueryExpression()
                            };
                        }
                    }),
                new OptionalExpression(
                    new GroupedExpressionConcat() {
                        @Override
                        protected Expression[] expressionList() {
                            return new Expression[] {
                                new StringExpression("\\#"),
                                new FragmentExpression()
                            };
                        }
                    })
            };
        }

        @Override
        protected String abnfDisplayName() {
            return "relative-ref";
        }
    }

    static class RelativePartExpression extends GroupedExpressionOr {
        @Override
        protected Expression[] expressionList() {
            return new Expression[] {
                new GroupedExpressionConcat() {
                    @Override
                    protected Expression[] expressionList() {
                        return new Expression[] {
                            new StringExpression("\\/\\/"),
                            new AuthorityExpression(),
                            new PathAbEmptyExpression()
                        };
                    }
                },
                new PathAbsoluteExpression(),
                new PathNoSchemeExpression(),
                new PathEmptyExpression()
            };
        }

        @Override
        protected String abnfDisplayName() {
            return "relative-part";
        }
    }

    static class SchemeExpression extends GroupedExpressionConcat {
        
        private String mConstantScheme;
        
        public SchemeExpression(String constantScheme) {
            mConstantScheme = constantScheme;
        }

        public SchemeExpression() {
        }

        @Override
        protected Expression[] expressionList() {
            return new Expression[] {
                new AlphaExpression(),
                new RepeatExpressionAsterisc(
                    new GroupedExpressionOr(true) {
                        @Override
                        protected Expression[] expressionList() {
                            return new Expression[] {
                                new AlphaExpression(),
                                new DigitExpression(),
                                new StringExpression("\\+"),
                                new StringExpression("\\-"),
                                new StringExpression("\\.")
                            };
                        }
                    })
            };
        }

        @Override
        public String regexp() {
            if ( TextUtils.isEmpty(mConstantScheme)) {
                return super.regexp();
            } else {
                return mConstantScheme;
            }
        }

        @Override
        protected String abnfDisplayName() {
            return "scheme";
        }

    }

    static class AuthorityExpression extends GroupedExpressionConcat {
        @Override
        protected Expression[] expressionList() {
            return new Expression[] {
                new OptionalExpression(
                    new GroupedExpressionConcat() {
                        @Override
                        protected Expression[] expressionList() {
                            return new Expression[] {
                                new UserInfoExpression(),
                                new StringExpression("\\@")
                            };
                        }
                    }),
                new HostExpression(),
                new OptionalExpression(
                    new GroupedExpressionConcat() {
                        @Override
                        protected Expression[] expressionList() {
                            return new Expression[] {
                                new StringExpression("\\:"),
                                new PortExpression()
                            };
                        }
                    })
            };
        }

        @Override
        protected String abnfDisplayName() {
            return "authority";
        }
    }

    static class UserInfoExpression extends RepeatExpressionAsterisc {
        public UserInfoExpression() {
            super(
                new GroupedExpressionOr(true) {
                    @Override
                    protected Expression[] expressionList() {
                        return new Expression[] {
                            new UnreservedExpression(),
                            new PctEncodedExpression(), 
                            new SubDelimsExpression(), 
                            new StringExpression("\\:")
                        };
                    }
                }
            );
        }

        @Override
        protected String abnfDisplayName() {
            return "userinfo";
        }
    }
    

    static class HostExpression extends GroupedExpressionOr {
        @Override
        protected Expression[] expressionList() {
            return new Expression[] {
                new IPLiteralExpression(),
                new IpV4AddressExpression(),
                new RegNameExpression()
            };
        }

        @Override
        protected String abnfDisplayName() {
            return "host";
        }
    }

    static class PortExpression extends RepeatExpressionAsterisc {
        public PortExpression() {
            super( new DigitExpression());
        }

        @Override
        protected String abnfDisplayName() {
            return "port";
        }
    }

    static class IPLiteralExpression extends GroupedExpressionConcat {
        @Override
        protected Expression[] expressionList() {
            return new Expression[] {
                new StringExpression("\\["),
                new GroupedExpressionOr(true) {
                    @Override
                    protected Expression[] expressionList() {
                        return new Expression[] {
                            new IPv6addressExpression(),
                            new IPvFutureExpression()
                        };
                    }
                },
                new StringExpression("\\]"),
            };
        }

        @Override
        protected String abnfDisplayName() {
            return "IP-literal";
        }
    }

    static class IPvFutureExpression extends GroupedExpressionConcat {
        @Override
        protected Expression[] expressionList() {
            return new Expression[] {
                new StringExpression("v"),
                new RepeatExpressionMore( new HexDigExpression(), 1),
                new StringExpression("\\."),
                new RepeatExpressionMore(
                    new GroupedExpressionOr(true) {
                        @Override
                        protected Expression[] expressionList() {
                            return new Expression[] {
                                new UnreservedExpression(),
                                new SubDelimsExpression(),
                                new StringExpression("\\:")
                            };
                        }
                    }, 1)
            };
        }

        @Override
        protected String abnfDisplayName() {
            return "IPvFuture";
        }
    }

    static class IPv6addressLeftFragment extends OptionalExpression {
        public IPv6addressLeftFragment(final int repeatCount) {
            super(
                new GroupedExpressionConcat() {
                    @Override
                    protected Expression[] expressionList() {
                        Expression[] expressions;
                        expressions = new Expression[2];
                        expressions[0] = new RepeatExpressionLess( new H16Colon(), repeatCount);
                        expressions[1] = new H16Expression();
                        return expressions;
                    }
                }
            );
        }
    }

    static class H16Colon extends GroupedExpressionConcat {

        public H16Colon() {
            super(true);
        }

        @Override
        protected Expression[] expressionList() {
            return new Expression[] {
                new H16Expression(),
                new StringExpression("\\:")
            };
        }
    }

    static class IPv6addressExpression extends GroupedExpressionOr {
        @Override
        protected Expression[] expressionList() {
            return new Expression[] {
                new GroupedExpressionConcat() {
                    @Override
                    protected Expression[] expressionList() {
                        return new Expression[] {
                            new RepeatExpressionCount( new H16Colon(), 6),
                            new Ls32Expression() 
                        };
                    }
                },
                new GroupedExpressionConcat() {
                    @Override
                    protected Expression[] expressionList() {
                        return new Expression[] {
                            new StringExpression("\\:\\:"),
                            new RepeatExpressionCount( new H16Colon(), 5),
                            new Ls32Expression() 
                        };
                    }
                },
                new GroupedExpressionConcat() {
                    @Override
                    protected Expression[] expressionList() {
                        return new Expression[] {
                            new OptionalExpression( new H16Expression() ),
                            new StringExpression("\\:\\:"),
                            new RepeatExpressionCount( new H16Colon(), 4),
                            new Ls32Expression() 
                        };
                    }
                },
                new GroupedExpressionConcat() {
                    @Override
                    protected Expression[] expressionList() {
                        return new Expression[] {
                            new IPv6addressLeftFragment(1),
                            new StringExpression("\\:\\:"),
                            new RepeatExpressionCount( new H16Colon(), 3),
                            new Ls32Expression() 
                        };
                    }
                },
                new GroupedExpressionConcat() {
                    @Override
                    protected Expression[] expressionList() {
                        return new Expression[] {
                            new IPv6addressLeftFragment(2),
                            new StringExpression("\\:\\:"),
                            new RepeatExpressionCount( new H16Colon(), 2),
                            new Ls32Expression() 
                        };
                    }
                },
                new GroupedExpressionConcat() {
                    @Override
                    protected Expression[] expressionList() {
                        return new Expression[] {
                            new IPv6addressLeftFragment(3),
                            new StringExpression("\\:\\:"),
                            new H16Expression(),
                            new StringExpression("\\:"),
                            new Ls32Expression() 
                        };
                    }
                },
                new GroupedExpressionConcat() {
                    @Override
                    protected Expression[] expressionList() {
                        return new Expression[] {
                            new IPv6addressLeftFragment(4),
                            new StringExpression("\\:\\:"),
                            new Ls32Expression() 
                        };
                    }
                },
                new GroupedExpressionConcat() {
                    @Override
                    protected Expression[] expressionList() {
                        return new Expression[] {
                            new IPv6addressLeftFragment(5),
                            new StringExpression("\\:\\:"),
                            new H16Expression() 
                        };
                    }
                },
                new GroupedExpressionConcat() {
                    @Override
                    protected Expression[] expressionList() {
                        return new Expression[] {
                            new IPv6addressLeftFragment(6),
                            new StringExpression("\\:\\:")
                        };
                    }
                }
            };
        }

        @Override
        protected String abnfDisplayName() {
            return "IPv6address";
        }
    }

    static class H16Expression extends RepeatExpressionRange {
        public H16Expression() {
            super(new HexDigExpression(), 1, 4);
        }

        @Override
        protected String abnfDisplayName() {
            return "h16";
        }
    }

    
    static class Ls32Expression extends GroupedExpressionOr {
        @Override
        protected Expression[] expressionList() {
            return new Expression[] {
                new GroupedExpressionConcat(true) {
                    @Override
                    protected Expression[] expressionList() {
                        return new Expression[] {
                            new H16Expression(),
                            new StringExpression("\\:"),
                            new H16Expression()
                        };
                    }
                },
                new IpV4AddressExpression()
            };
        }

        @Override
        protected String abnfDisplayName() {
            return "ls32";
        }
    }

    static class IpV4AddressExpression extends GroupedExpressionConcat {
        @Override
        protected Expression[] expressionList() {
            return new Expression[] {
                new DecOctetExpression(),
                new StringExpression( "\\." ),
                new DecOctetExpression(),
                new StringExpression( "\\." ),
                new DecOctetExpression(),
                new StringExpression( "\\." ),
                new DecOctetExpression()
            };
        }

        @Override
        protected String abnfDisplayName() {
            return "IPv4address";
        }
    }

    static class DecOctetExpression extends GroupedExpressionOr {
        @Override
        protected boolean reverse() {
            return true;
        }

        @Override
        protected Expression[] expressionList() {
            return new Expression[] {
                new DigitExpression(),
                new GroupedExpressionConcat() {
                    @Override
                    protected Expression[] expressionList() {
                        return new Expression[] {
                            new ValueRangeExpression( 0x31, 0x39 ),
                            new DigitExpression()
                        };
                    }
                },
                new GroupedExpressionConcat() {
                    @Override
                    protected Expression[] expressionList() {
                        return new Expression[] {
                            new StringExpression("1"),
                            new RepeatExpressionCount( new DigitExpression(), 2)
                        };
                    }
                },
                new GroupedExpressionConcat() {
                    @Override
                    protected Expression[] expressionList() {
                        return new Expression[] {
                            new StringExpression("2"),
                            new ValueRangeExpression( 0x30, 0x34),
                            new DigitExpression()
                        };
                    }
                },
                new GroupedExpressionConcat() {
                    @Override
                    protected Expression[] expressionList() {
                        return new Expression[] {
                            new StringExpression("25"),
                            new ValueRangeExpression(0x30, 0x35)
                        };
                    }
                }
            };
        }

        @Override
        protected String abnfDisplayName() {
            return "dec-octet";
        }
    }

    static class RegNameExpression extends RepeatExpressionAsterisc {
        public RegNameExpression() {
            super(
                new GroupedExpressionOr(true) {
                    @Override
                    protected Expression[] expressionList() {
                        return new Expression[] {
                            new UnreservedExpression(),
                            new PctEncodedExpression(), 
                            new SubDelimsExpression()
                        };
                    }
                }
            );
        }

        @Override
        protected String abnfDisplayName() {
            return "reg-name";
        }
    }

    static class PathExpression extends GroupedExpressionOr {
        @Override
        protected Expression[] expressionList() {
            return new Expression[] {
                new PathAbEmptyExpression(),
                new PathAbsoluteExpression(),
                new PathNoSchemeExpression(),
                new PathRootlessExpression(),
                new PathEmptyExpression()
            };
        }

        @Override
        protected String abnfDisplayName() {
            return "path";
        }
    }

    static class PathAbEmptyExpression extends RepeatExpressionAsterisc {
        public PathAbEmptyExpression() {
            super(
                new GroupedExpressionConcat(true) {
                    @Override
                    protected Expression[] expressionList() {
                        return new Expression[] {
                            new StringExpression( "\\/" ),
                            new SegmentExpression()
                        };
                    }
                }
            );
        }

        @Override
        protected String abnfDisplayName() {
            return "path-abempty";
        }
    }

    static class PathAbsoluteExpression extends GroupedExpressionConcat {
        @Override
        protected Expression[] expressionList() {
            return new Expression[] {
                new StringExpression("\\/"),
                new OptionalExpression(
                    new GroupedExpressionConcat() {
                        @Override
                        protected Expression[] expressionList() {
                            return new Expression[] {
                                new SegmentNzExpression(),
                                new RepeatExpressionAsterisc(
                                    new GroupedExpressionConcat(true) {
                                        @Override
                                        protected Expression[] expressionList() {
                                            return new Expression[] {
                                                new StringExpression( "\\/" ),
                                                new SegmentExpression()
                                            };
                                        }
                                    })
                            };
                        }
                    })
            };
        }

        @Override
        protected String abnfDisplayName() {
            return "path-absolute";
        }
    }

    static class PathNoSchemeExpression extends GroupedExpressionConcat {
        @Override
        protected Expression[] expressionList() {
            return new Expression[] {
                new SegmentNzNcExpression(),
                new RepeatExpressionAsterisc(
                    new GroupedExpressionConcat(true) {
                        @Override
                        protected Expression[] expressionList() {
                            return new Expression[] {
                                new StringExpression("\\/"),
                                new SegmentExpression()
                            };
                        }
                    })
            };
        }

        @Override
        protected String abnfDisplayName() {
            return "path-noscheme";
        }
    }

    static class PathRootlessExpression extends GroupedExpressionConcat {
        @Override
        protected Expression[] expressionList() {
            return new Expression[] {
                new SegmentNzExpression(),
                new RepeatExpressionAsterisc( 
                    new GroupedExpressionConcat(true) {
                        @Override
                        protected Expression[] expressionList() {
                            return new Expression[] {
                                new StringExpression("\\/"),
                                new SegmentExpression()
                            };
                        }
                    })
            };
        }

        @Override
        protected String abnfDisplayName() {
            return "path-rootless";
        }
    }

    static class PathEmptyExpression extends StringExpression {
        public PathEmptyExpression() {
            super("");
        }

        @Override
        protected String abnfDisplayName() {
            return "path-empty";
        }

        @Override
        public String abnf() {
            return "0<pchar>";
        }
    }

    static class SegmentExpression extends RepeatExpressionAsterisc {
        public SegmentExpression() {
            super( new PCharExpression() );
        }

        @Override
        protected String abnfDisplayName() {
            return "segment";
        }
    }
    
    static class SegmentNzExpression extends RepeatExpressionMore {
        public SegmentNzExpression() {
            super( new PCharExpression(), 1);
        }

        @Override
        protected String abnfDisplayName() {
            return "segment-nz";
        }
    }

    static class SegmentNzNcExpression extends RepeatExpressionMore {

        public SegmentNzNcExpression() {
            super(
                new GroupedExpressionOr(true) {
                    @Override
                    protected Expression[] expressionList() {
                        return new Expression[] {
                            new UnreservedExpression(),
                            new PctEncodedExpression(),
                            new SubDelimsExpression(),
                            new StringExpression("\\@")            
                        };
                    }
                }
                , 1);
        }

        @Override
        protected String abnfDisplayName() {
            return "segment-nz-nc";
        }

    }    

    static class PCharExpression extends GroupedExpressionOr {
        @Override
        protected Expression[] expressionList() {
            return new Expression[] {
                new UnreservedExpression(),
                new PctEncodedExpression(),
                new SubDelimsExpression(),
                new StringExpression("\\:"),
                new StringExpression("\\@")
            };
        }

        @Override
        protected String abnfDisplayName() {
            return "pchar";
        }
    }

    static class QueryExpression extends RepeatExpressionAsterisc {
        public QueryExpression() {
            super(
                new GroupedExpressionOr(true) {
                    @Override
                    protected Expression[] expressionList() {
                        return new Expression[] {
                            new PCharExpression(), 
                            new StringExpression("\\/"),
                            new StringExpression( "\\?" )            
                        };
                    }
                }
            );
        }

        @Override
        protected String abnfDisplayName() {
            return "query";
        }
    }

    static class FragmentExpression extends RepeatExpressionAsterisc {
        public FragmentExpression() {
            super(
                new GroupedExpressionOr(true) {
                    @Override
                    protected Expression[] expressionList() {
                        return new Expression[] {
                            new PCharExpression(), 
                            new StringExpression("\\/"),
                            new StringExpression( "\\?" )                
                        };
                    }
                }
            );
        }

        @Override
        protected String abnfDisplayName() {
            return "fragment";
        }
    }

    static class PctEncodedExpression extends GroupedExpressionConcat {
        @Override
        protected Expression[] expressionList() {
            return new Expression[] {
                new StringExpression("\\%"),
                new HexDigExpression(),
                new HexDigExpression()
            };
        }

        @Override
        protected String abnfDisplayName() {
            return "pct-encoded";
        }
    }

    static class UnreservedExpression extends GroupedExpressionOr {
        @Override
        protected Expression[] expressionList() {
            return new Expression[] {
                new AlphaExpression(),
                new DigitExpression(),
                new StringExpression("\\-"),
                new StringExpression("\\."),
                new StringExpression("\\_"),
                new StringExpression("\\~")
            };
        }

        @Override
        protected String abnfDisplayName() {
            return "unreserved";
        }
    }

    static class ReservedExpression extends GroupedExpressionOr {
        @Override
        protected Expression[] expressionList() {
            return new Expression[] {
                new GenDelimExpression(),
                new SubDelimsExpression()                
            };
        }

        @Override
        protected String abnfDisplayName() {
            return "reserved";
        }
    }

    static class GenDelimExpression extends GroupedExpressionOr {
        @Override
        protected Expression[] expressionList() {
            return new Expression[] {
                new StringExpression("\\:"),
                new StringExpression("\\/"),
                new StringExpression("\\?"),
                new StringExpression("\\#"),
                new StringExpression("\\["),
                new StringExpression("\\]"),
                new StringExpression("\\@")
            };
        }

        @Override
        protected String abnfDisplayName() {
            return "gen-delims";
        }
    }

    static class SubDelimsExpression extends GroupedExpressionOr {
        @Override
        protected Expression[] expressionList() {
            return new Expression[] {
                new StringExpression("\\!"),
                new StringExpression("\\$"),
                new StringExpression("\\&"),
                new StringExpression("\\'"),
                new StringExpression("\\("),
                new StringExpression("\\)"),
                new StringExpression("\\*"),
                new StringExpression("\\+"),
                new StringExpression("\\,"),
                new StringExpression("\\;"),
                new StringExpression("\\=")
            };
        }

        @Override
        protected String abnfDisplayName() {
            return "sub-delims";
        }
    }

    static String excludeBackSlash( String s ) {
        return s.replaceAll("\\\\", "");
    }

    static String quotedString( String s ) {
        return "\"" +  s + "\"";
    }

    static class HexDigExpression extends StringExpression {
        public HexDigExpression() {
            super("[0-9a-fA-F]");
        }

        @Override
        public String abnf() {
            return "HEXDIG";
        }
    }

    static class ValueRangeExpression extends Expression {
        private int mFromValue;
        private int mToValue; 
        
        public ValueRangeExpression( int fromValue, int toValue ) {
            mFromValue = fromValue;
            mToValue = toValue;
        }

        @Override
        public String regexp() {
            return String.format( "[\\x%02x-\\x%02x]", mFromValue, mToValue );
        }

        @Override
        public String abnf() {
            return String.format( "%%x%02x-%02x", mFromValue, mToValue );
        }
    }

    static class DigitExpression extends ValueRangeExpression {
        public DigitExpression() {
            super( 0x30, 0x39 );
        }

        @Override
        public String abnf() {
            return "DIGIT";
        }
    }

    static class AlphaExpression extends StringExpression {
        public AlphaExpression() {
            super("[a-zA-Z]");
        }

        @Override
        public String abnf() {
            return "ALPHA";
        }
    }

    public static String generate( String concreteSchemeExpression) {
        URIExpression uri = new URIExpression(concreteSchemeExpression);
        return uri.regexp();
    }

    public static String generate() {
        return generate( "https?");
    }

    static URIRegExpGenerator.Expression[] createExpressionList() {
        return new URIRegExpGenerator.Expression[] {
            new URIRegExpGenerator.URIExpression(),
            new URIRegExpGenerator.HierPartExpression(),
            new URIRegExpGenerator.URIReferenceExpression(),
            new URIRegExpGenerator.AbsoluteURIExpression(),
            new URIRegExpGenerator.RelativeRefExpression(),
            new URIRegExpGenerator.RelativePartExpression(),
            new URIRegExpGenerator.SchemeExpression(),
            new URIRegExpGenerator.AuthorityExpression(),
            new URIRegExpGenerator.UserInfoExpression(),
            new URIRegExpGenerator.HostExpression(),
            new URIRegExpGenerator.PortExpression(),
            new URIRegExpGenerator.IPLiteralExpression(),
            new URIRegExpGenerator.IPvFutureExpression(),
            new URIRegExpGenerator.IPv6addressExpression(),
            new URIRegExpGenerator.H16Expression(),
            new URIRegExpGenerator.Ls32Expression(),
            new URIRegExpGenerator.IpV4AddressExpression(),
            new URIRegExpGenerator.DecOctetExpression(),
            new URIRegExpGenerator.RegNameExpression(),
            new URIRegExpGenerator.PathExpression(),
            new URIRegExpGenerator.PathAbEmptyExpression(),
            new URIRegExpGenerator.PathAbsoluteExpression(),
            new URIRegExpGenerator.PathNoSchemeExpression(),
            new URIRegExpGenerator.PathRootlessExpression(),
            new URIRegExpGenerator.PathEmptyExpression(),
            new URIRegExpGenerator.SegmentExpression(),
            new URIRegExpGenerator.SegmentNzExpression(),
            new URIRegExpGenerator.SegmentNzNcExpression(),
            new URIRegExpGenerator.PCharExpression(),
            new URIRegExpGenerator.QueryExpression(),
            new URIRegExpGenerator.FragmentExpression(),
            new URIRegExpGenerator.PctEncodedExpression(),
            new URIRegExpGenerator.UnreservedExpression(),
            new URIRegExpGenerator.ReservedExpression(),
            new URIRegExpGenerator.GenDelimExpression(),
            new SubDelimsExpression()
        };
    }

    public static String createAbnfText() {
        URIRegExpGenerator.Expression expressions[] = createExpressionList();

        StringBuilder sb = new StringBuilder();
        for ( int i = 0; i < expressions.length; i++ ) {
            URIRegExpGenerator.Expression exp = expressions[i];
            sb.append( exp.abnfDisplayName() );
            sb.append( " = " );
            sb.append( exp.abnf() );
            sb.append( "\r\n" );
        }
        return sb.toString();
    }
}