import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Iterator;

public class Q2 {


    public enum TokenType {

        // Operators
        OP_MULTIPLY ('*', "operator"),
        OP_DIVIDE ('/', "operator"),
        OP_MOD ('%', "operator"),
        OP_ADD ('+', "operator"),
        OP_SUBTRACT ('-', "operator"),
        OP_LESS ('<', "operator"),
        OP_LESSEQUAL ("<=", "operator"),
        OP_GREATER ('>', "operator"),
        OP_GREATEREQUAL (">=", "operator"),
        OP_EQUAL ("==", "operator"),
        OP_NOTEQUAL ("!=", "operator"),
        OP_NOT ('!', "operator"),
        OP_ASSIGN ('=', "operator"),
        OP_AND ("&&", "operator"),
        OP_OR ("||", "operator"),
        OP_DOT ('.', "operator"),

        // Symbols
        LEFT_PAREN ('(', "symbol"),
        RIGHT_PAREN (')', "symbol"),
        LEFT_BRACE ('{', "symbol"),
        RIGHT_BRACE ('}', "symbol"),
        LEFT_BRACKET ('[', "symbol"),
        RIGHT_BRACKET (']', "symbol"),
        SEMICOLON (';', "symbol"),
        COLON (':', "symbol"),
        COMMA (',', "symbol"),

        // Keywords
        KEYWORD_IF ("if", "keyword"),
        KEYWORD_ELSE ("else", "keyword"),
        KEYWORD_WHILE ("while", "keyword"),
        KEYWORD_RETURN ("return", "keyword"),
        KEYWORD_MAIN ("main", "keyword"),
        KEYWORD_INT ("int", "keyword"),
        KEYWORD_DOUBLE ("double", "keyword"),
        KEYWORD_BOOLEAN ("boolean", "keyword"),
        KEYWORD_STRING ("String", "keyword"),
        KEYWORD_PUBLIC ("public", "keyword"),
        KEYWORD_CLASS ("class", "keyword"),
        KEYWORD_VOID ("void", "keyword"),
        KEYWORD_FOR ("for", "keyword"),
        KEYWORD_CASE ("case", "keyword"),
        KEYWORD_STATIC ("static", "keyword"),
        KEYWORD_BREAK ("break", "keyword"),
        KEYWORD_CONTINUE ("continue", "keyword"),
        KEYWORD_DEFAULT ("default", "keyword"),

        // Identifiers and literals
        IDENTIFIER ("identifier", "identifier"),
        INTEGER ("integer", "literal"),
        DOUBLE ("double", "literal"),
        STRING ("string", "literal"),
        BOOLEAN ("boolean", "literal");

        String name;
        String type;

        char nameCh;

        TokenType(String name, String type) {
            this.name = name;
            this.type = type;
        }

        TokenType(char nameCh, String type) {
            this.nameCh = nameCh;
            this.type = type;
        }

        public String getName() {
            return name;
        }

        public char getNameCh() {
            return nameCh;
        }

        public String getType() {
            return type;
        }

        public static TokenType getToken(String str) {
            for(TokenType t : TokenType.values()) {
                if(t.getName() != null) {
                    if(t.getName().contentEquals(str)) {}
                    return t;
                }
                else if(t.getNameCh() == str.charAt(0)) {
                    return t;
                }
            }
            return null;
        }
    }

    public static void main(String[] args) {
        String prog = "";
        if (args.length > 0) {
            prog = readFile(args[0]);

            scan(prog);
        }
        else {
            System.out.println("No arguments found.");
            System.out.println("Please supply directory to .java file as an argument.");
        }
    }

    public static String readFile(String fname) {
        String content = null;

        try {
            content = new String(Files.readAllBytes(Paths.get(fname)));
        } catch (IOException e) {
            System.out.println("Fail to read a file");
        }

        return content;
    }

    public static void scan (String prog) {
        String lines[] = prog.split("\n");

        int i = 1;

        for (String line : lines) {
            processLine(line, i);
            i++;
        }
    }

    public static TokenType tokenName(String str) {
        TokenType tokenName = null;
        for(TokenType t : TokenType.values()) {
            if(t.getName().equals(str)) {
                tokenName = t;
                return tokenName;
            }
            else if(t.getNameCh() == str.charAt(0)) {
                tokenName = t;
                return tokenName;
            }
            else {
                return TokenType.IDENTIFIER;
            }
        }
        return tokenName;
    }

    private static void processLine(String line, int i) {
        tokenizer T = new tokenizer (line);

        ArrayList <String> tokens = T.token();
        Iterator<String> itr = tokens.iterator();

        while (itr.hasNext()) {
            String str = itr.next();
            System.out.println(i + ", " + str + ", " + TokenType.getToken(str));
        }

        System.out.println("");
    }

    public static TokenType getOp (char ch) {
        return checkCh(ch, "operator");
    }

    public static TokenType getOp (String s) {
        return checkS(s, "operator");
    }

    public static TokenType getSymbol (char ch) {
        return checkCh(ch, "symbol");
    }

    public static TokenType getKeyword (String s) {
        return checkS(s, "keyword");
    }

    public static TokenType checkCh (char ch, String type) {
        for (TokenType value : TokenType.values()) {
            if (value.getType() == type && value.getNameCh() == ch) {
                return value;
            }
        }

        return null;
    }

    public static TokenType checkS (String s, String type) {
        for (TokenType value : TokenType.values()) {
            if (value.getType() == type && value.getName() != null) {
                if (value.getName().equals(s)) {
                    return value;
                }
            }
        }

        return null;
    }

    public static boolean isLetter (char ch) {
        return Character.isLetter(ch);
    }

    public static boolean isDigit (char ch) {
        return Character.isDigit(ch);
    }

    public static boolean isWhiteSpace (char ch) {
        return (ch == ' ' || ch == '\t' || ch == '\n')? true : false;
    }

    public static boolean isOp (char ch) {
        for (TokenType value : TokenType.values()) {
            if (value.getType() == "operator" && value.getNameCh() == ch) {
                return true;
            }
        }

        return false;
    }

    public static boolean isSymbol (char ch) {
        for (TokenType value : TokenType.values()) {
            if (value.getType() == "symbol" && value.getNameCh() == ch) {
                return true;
            }
        }

        return false;
    }
}