/*

 * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package java.util.regex;

import java.util.HashMap;

import java.util.Locale;

enum UnicodeProp {

    ALPHABETIC {

        public boolean is(int ch) {

            return Character.isAlphabetic(ch);

        }

    },

    LETTER {

        public boolean is(int ch) {

            return Character.isLetter(ch);

        }

    },

    IDEOGRAPHIC {

        public boolean is(int ch) {

            return Character.isIdeographic(ch);

        }

    },

    LOWERCASE {

        public boolean is(int ch) {

            return Character.isLowerCase(ch);

        }

    },

    UPPERCASE {

        public boolean is(int ch) {

            return Character.isUpperCase(ch);

        }

    },

    TITLECASE {

        public boolean is(int ch) {

            return Character.isTitleCase(ch);

        }

    },

    WHITE_SPACE {

        // \p{Whitespace}

        public boolean is(int ch) {

            return ((((1 << Character.SPACE_SEPARATOR) |

                      (1 << Character.LINE_SEPARATOR) |

                      (1 << Character.PARAGRAPH_SEPARATOR)) >> Character.getType(ch)) & 1)

                   != 0 || (ch >= 0x9 && ch <= 0xd) || (ch == 0x85);

        }

    },

    CONTROL {

        // \p{gc=Control}

        public boolean is(int ch) {

            return Character.getType(ch) == Character.CONTROL;

        }

    },

    PUNCTUATION {

        // \p{gc=Punctuation}

        public boolean is(int ch) {

            return ((((1 << Character.CONNECTOR_PUNCTUATION) |

                      (1 << Character.DASH_PUNCTUATION) |

                      (1 << Character.START_PUNCTUATION) |

                      (1 << Character.END_PUNCTUATION) |

                      (1 << Character.OTHER_PUNCTUATION) |

                      (1 << Character.INITIAL_QUOTE_PUNCTUATION) |

                      (1 << Character.FINAL_QUOTE_PUNCTUATION)) >> Character.getType(ch)) & 1)

                   != 0;

        }

    },

    HEX_DIGIT {

        // \p{gc=Decimal_Number}

        // \p{Hex_Digit}    -> PropList.txt: Hex_Digit

        public boolean is(int ch) {

            return DIGIT.is(ch) ||

                   (ch >= 0x0030 && ch <= 0x0039) ||

                   (ch >= 0x0041 && ch <= 0x0046) ||

                   (ch >= 0x0061 && ch <= 0x0066) ||

                   (ch >= 0xFF10 && ch <= 0xFF19) ||

                   (ch >= 0xFF21 && ch <= 0xFF26) ||

                   (ch >= 0xFF41 && ch <= 0xFF46);

        }

    },

    ASSIGNED {

        public boolean is(int ch) {

            return Character.getType(ch) != Character.UNASSIGNED;

        }

    },

    NONCHARACTER_CODE_POINT {

        // PropList.txt:Noncharacter_Code_Point

        public boolean is(int ch) {

            return (ch & 0xfffe) == 0xfffe || (ch >= 0xfdd0 && ch <= 0xfdef);

        }

    },

    DIGIT {

        // \p{gc=Decimal_Number}

        public boolean is(int ch) {

            return Character.isDigit(ch);

        }

    },

    ALNUM {

        // \p{alpha}

        // \p{digit}

        public boolean is(int ch) {

            return ALPHABETIC.is(ch) || DIGIT.is(ch);

        }

    },

    BLANK {

        // \p{Whitespace} --

        // [\N{LF} \N{VT} \N{FF} \N{CR} \N{NEL}  -> 0xa, 0xb, 0xc, 0xd, 0x85

        //  \p{gc=Line_Separator}

        //  \p{gc=Paragraph_Separator}]

        public boolean is(int ch) {

            return Character.getType(ch) == Character.SPACE_SEPARATOR ||

                   ch == 0x9; // \N{HT}

        }

    },

    GRAPH {

        // [^

        //  \p{space}

        //  \p{gc=Control}

        //  \p{gc=Surrogate}

        //  \p{gc=Unassigned}]

        public boolean is(int ch) {

            return ((((1 << Character.SPACE_SEPARATOR) |

                      (1 << Character.LINE_SEPARATOR) |

                      (1 << Character.PARAGRAPH_SEPARATOR) |

                      (1 << Character.CONTROL) |

                      (1 << Character.SURROGATE) |

                      (1 << Character.UNASSIGNED)) >> Character.getType(ch)) & 1)

                   == 0;

        }

    },

    PRINT {

        // \p{graph}

        // \p{blank}

        // -- \p{cntrl}

        public boolean is(int ch) {

            return (GRAPH.is(ch) || BLANK.is(ch)) && !CONTROL.is(ch);

        }

    },

    WORD {

        //  \p{alpha}

        //  \p{gc=Mark}

        //  \p{digit}

        //  \p{gc=Connector_Punctuation}

        public boolean is(int ch) {

            return ALPHABETIC.is(ch) ||

                   ((((1 << Character.NON_SPACING_MARK) |

                      (1 << Character.ENCLOSING_MARK) |

                      (1 << Character.COMBINING_SPACING_MARK) |

                      (1 << Character.DECIMAL_DIGIT_NUMBER) |

                      (1 << Character.CONNECTOR_PUNCTUATION)) >> Character.getType(ch)) & 1)

                   != 0;

        }

    };

    private final static HashMap<String, String> posix = new HashMap<>();

    private final static HashMap<String, String> aliases = new HashMap<>();

    static {

        posix.put("ALPHA", "ALPHABETIC");

        posix.put("LOWER", "LOWERCASE");

        posix.put("UPPER", "UPPERCASE");

        posix.put("SPACE", "WHITE_SPACE");

        posix.put("PUNCT", "PUNCTUATION");

        posix.put("XDIGIT","HEX_DIGIT");

        posix.put("ALNUM", "ALNUM");

        posix.put("CNTRL", "CONTROL");

        posix.put("DIGIT", "DIGIT");

        posix.put("BLANK", "BLANK");

        posix.put("GRAPH", "GRAPH");

        posix.put("PRINT", "PRINT");

        aliases.put("WHITESPACE", "WHITE_SPACE");

        aliases.put("HEXDIGIT","HEX_DIGIT");

        aliases.put("NONCHARACTERCODEPOINT", "NONCHARACTER_CODE_POINT");

    }

    public static UnicodeProp forName(String propName) {

        propName = propName.toUpperCase(Locale.ENGLISH);

        String alias = aliases.get(propName);

        if (alias != null)

            propName = alias;

        try {

            return valueOf (propName);

        } catch (IllegalArgumentException x) {}

        return null;

    }

    public static UnicodeProp forPOSIXName(String propName) {

        propName = posix.get(propName.toUpperCase(Locale.ENGLISH));

        if (propName == null)

            return null;

        return valueOf (propName);

    }

    public abstract boolean is(int ch);

}