package calc;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.StringTokenizer;

import static java.lang.Character.getNumericValue;
import static java.lang.Character.isDigit;
import static java.lang.Double.NaN;


/*
 *   A calculator for rather simple arithmetic expressions
 *
 *   NOTE:
 *   - No real or negative numbers implemented
 */
public class Calculator {

    // Error messages (more on static later)
    final static String MISSING_OPERAND = "Missing or bad operand";
    final static String DIV_BY_ZERO = "Division with 0";

    // Definition of operators
    final static String OPERATORS = "+-*/^";

    // Method used in REPL
    double eval(String expr) {
        if (expr.length() == 0) {
            return NaN;
        }
        List<String> tokens = tokenize(expr);
        List<String> postfix = infix2Postfix(tokens);
        return evalPostfix(postfix);
    }

    // ------  Evaluate RPN expression -------------------

    double evalPostfix(List<String> postfix) {
        // TODO
        return 0;
    }


    // ------- Infix 2 Postfix ------------------------

    // Error messages
    final static String MISSING_OPERATOR = "Missing operator or parenthesis";
    final static String OP_NOT_FOUND = "Operator not found";

    List<String> infix2Postfix(List<String> infix) {
        // TODO

        return null;
    }

    // ---------- Tokenize -----------------------

    List<String> tokenize(String expr) {
        // TODO
        //StringTokenizer string= new StringTokenizer(expr," ");
        //"+-/*".contains(string);
        //String[] result =myString.split(string);
        List<String> res = new ArrayList<>();


        for(int i = 0; i < expr.length(); i++) {
            if(isOperator(expr.charAt(i)) ) {
                res.add(Character.toString(expr.charAt(i)));
            }


        }return res; }

    List<String> digits(String expr){
        List<String> digits= new ArrayList<>();
        for(int i = 0; i < expr.length(); i++){
            int raise=0;
            int sum=0;

        if(!isOperator(expr.charAt(i)) && isDigit(expr.charAt(i))){
            int j=i;

            while(Validlocation(expr,j) && isDigit(expr.charAt(j))){j++;}
            j--;
            for(int k =i; k <=j; k++){

                int a=(int) Math.round(Math.pow(10,j));
                int b= getNumericValue(expr.charAt(i));
                sum= a*b+sum;
                j--;
            }
           String Stringsum= Integer.toString(sum);
            digits.add(Stringsum);
            }

        }

    return digits;}

    boolean Validlocation(String expr,int j){
        boolean status=false;

        if ( 0<=j  && j<expr.length()){
            status=true;}
        return status;}

    boolean isOperator(char c) {
        return c == '*' || c == '+' || c == '-' || c == '/';
    }



    char[] returnOperator(String expr) {
        int amountop = 0;
        for (int i = 0; i < expr.length(); i++) {
            if (expr.charAt(i) == '*' || expr.charAt(i) == '/' || expr.charAt(i) == '(' || expr.charAt(i) == '+' || expr.charAt(i) == '-' || expr.charAt(i) == ')') {
                amountop++;
            }
        }
        // räknar hur många operatorer det finns
        char[] Operator = new char[amountop];
        for (int j = 0; j < amountop; j++)
            if (expr.charAt(j) == '*' || expr.charAt(j) == '/' || expr.charAt(j) == '(' || expr.charAt(j) == '+' || expr.charAt(j) == '-' || expr.charAt(j) == ')')
            {Operator[j] =expr.charAt(j);} // om operator stoppar vi det in i array}
    return Operator;}


    char[] returnDigits(String expr){
            char[] array = new char[expr.length()];
            int amountdig = 0;
            char s;
            for (int j = 0; j < expr.length(); j++) {
                s = expr.charAt(j);
                if (Character.isDigit(s)) {
                    amountdig++;
                }
            }
            char[] digarray = new char[amountdig];
            for (int i = 0; i <digarray.length; i++){
                s = expr.charAt(i);
                if (Character.isDigit(s)) {
                    digarray[i]=expr.charAt(i);
                }
            }
        return digarray;}










    // ----------- Helpers ------------------------

    int getPrecedence(String op) {
        if ("+-".contains(op)) {
            return 2;
        } else if ("*/".contains(op)) {
            return 3;
        } else if ("^".contains(op)) {
            return 4;
        } else {
            throw new RuntimeException(OP_NOT_FOUND);
        }
    }

    Assoc getAssociativity(String op) {
        if ("+-*/".contains(op)) {
            return Assoc.LEFT;
        } else if ("^".contains(op)) {
            return Assoc.RIGHT;
        } else {
            throw new RuntimeException(OP_NOT_FOUND);
        }
    }

    enum Assoc {
        LEFT,
        RIGHT
    }


}