import java.util.Scanner;
import java.util.Arrays;
/*
Online Java - IDE, Code Editor, Compiler

Online Java is a quick and easy tool that helps you to build, compile, test your programs online.
*/
public class Main
{
       public static void main(String[] args) {
        
        System.out.println("Welcome to Online IDE!! Happy Coding :)");
        
        char[] acceptedNumerals = new char[]{'M','D','C','L','X', 'V','I'};
        //These are all accepted roman numerals
         
        int number; //This is set once end user specifies number numerals in their number to be inputted
     
        boolean noMatch=true;  // this flag is used to check if the numeral entered is a valid one
       
        int j;  //used to increment the character array containing user input of numeral
        int count=0;  // this keeps track number times end user has entered a character. It can be decremented if it fails validation.
        
        Scanner reader=null;
        
        // This is used to ascertain how many digits end user wants
        reader = new Scanner(System.in); // Reading from System.in
        System.out.println("Enter number numerals in the number to be converted to decimal:");
        number=reader.nextInt();
        
        char inputtedNumerals[] = new char[number];   // this creates character array with end user specified size
        int [][] posValues = new int [number][2];  // this is used to keep track of:
        
         // this is 2D array. 'number' simply increments with array index of the roman numeral in character array 
        // the multidimensal aspect at 0 index will store:  index of which numeral i.e  M is 0, D is 1
                             //aspect at 1 index will store:  decimal conversion
        // This will support later analysis.
        
        //all values will be set to 1 to ensure a repeat conversion is not processed;
        
do
{
reader = new Scanner(System.in); // Reading from System.in
System.out.println("Enter roman numeral " + (count+1) + " of " + number + ":");   // end user prompted to enter roman numeral
inputtedNumerals[count]=reader.next().charAt(0);
count++;

for (j=0; j<inputtedNumerals.length;j++)  // this will check each item in the inputted area against 7 roman numerals.
                                          // the condition could equally be set to count for better loop efficiency if the 
                                          //number entered is long
{

    for (int k=0; k<acceptedNumerals.length;k++)  // this goes through roman numerals
    {
    
    if (inputtedNumerals[j]==acceptedNumerals[k])  // this checks to see if the roman numerals entered are valid
    {
        
        posValues[count-1][0]=k;         // Variable k keeps a record of index of the roman numeral stored in acceptedNumerals      
        
        // This switch statement now checks 'k'validposition in hierarcy of the 7 numerals.
        //'M','D','C','L','X', 'V','I'
        
        // Depending on the roman numeral value, it will also store the decimal conversion into posValues array.
        switch(k)
        {
            case 0:
                posValues[count-1][1]=1000;
                break;
            
            case 1:
                posValues[count-1][1]=500;
                break;
                
            case 2:
                posValues[count-1][1]=100;
                break;
                
            case 3:
                posValues[count-1][1]=50;
                break;
                
            case 4:
                posValues[count-1][1]=10;
                break;
                
            case 5:
                posValues[count-1][1]=5;
                break;
                
            case 6:
                posValues[count-1][1]=1;
                break;
        }
        
        
        noMatch=false;   // This sets flag stating match has been found.
        break;
        
        }
    
}
// This will now give information if the user input is valid for each numeral.
// If found to be incorrect, the count will go back and end user will need to enter it again.

 if (noMatch==true)
    {
       System.out.println("Please input a successful roman numeral:  M  D  C  L  X  V  I");
       count=count-1;
       break;
    }
    
}

} while (count<inputtedNumerals.length);  // do while loop will end once count reaches the input user for length of roman numerals.


String str = String.valueOf(inputtedNumerals);
System.out.println("This will be converted to decimal:" + str);  // This informs end user of the roman numerals to be converted

performConversion pc = new performConversion(acceptedNumerals, inputtedNumerals,posValues,str); // calls constructor in class to perform conversion
}
}

class performConversion
{
    int sumNotAdded=0;
    int rule4;
    boolean rule3Fail=false;
    char[] inputtedNumerals;  // this contains numerals entered by end user
    
    char[] acceptedNumerals;  // this contains array of all accepted numerals
    int [][] posValues; // this keeps track for the  index for numeral and also its conversion into decimal
    int total; 
    int sum;
    int consecutiveOccurrences; 
    String numeralsToString;
    boolean correctOrder=false;
    
    int oneNumeral;
    int twoNumerals;
    
     // This is the constructor used to call the converter method.
     
    public performConversion (char[] aNumerals, char [] inputNumerals, int [][] pValues, String numeralsToString)
    {
        
        int pc[] = new int[pValues.length];
        this.acceptedNumerals=aNumerals;
        this.inputtedNumerals=inputNumerals;
        this.posValues=pValues;
        this.numeralsToString=numeralsToString;
        
        converter(pc);   // this variable has been passed into the method since for some reason it did not pick up the variable even though scope was correct.
    }
    public void converter(int [] processedConversion)
    {
        // There will be NO issues in performing conversion of a single roman numeral
        System.out.println("the length is:" + inputtedNumerals.length);
        if (inputtedNumerals.length<2)    // This functions correctly.
        {
                System.out.println("Conversion is single:" + posValues[0][1]);
                
                processedConversion[0]=1;
                //oneNumeral = oneNumeral + posValues[0][1];
                System.exit(0);
        }
        
              // ONCE ALL PRINCIPLES ARE UNDERSTOOD FOR A VALID ROMAN NUMERAL, THE CODE WILL BE IMPLEMENTED FURTHER     
            
           
        System.out.println("numerals in the roman numeral:" + posValues.length);
        
        int valueConsecutiveOccurences[] = new int [posValues.length];
        int indexCount=0;
        
        // These values can only occur once in roman numeral. A counter is kept.
        int countV=0;   
        int countL=0;
        int countD=0;
        
        boolean VLDcheck=false;
        
        int zeroIndexCount=0;  // on instances, the counter has to start from zeroindex notation
        
        int rule4Single=0;  //this keeps a total of rule 4
        
        int rule5=0;  // this keeps total at rule 5
        int rule5total;
        boolean rule5State=false;  // state is set if rule 5 is entered
        
        int rule6=0;     // this keeps total at rule 6
        int rule6total;   
        boolean rule6State=false;  // state is set if rule 6 is entered
        
        int rule7=0;    // this keeps total at rule 7
        int rule7total;
        boolean rule7State=false;  // state is set if rule 7 is entered
        
        // used for rule 4
         //Rule 4: Only I, X, and C can be used as subtractive numerals. 
            //There can be 6 combinations when we subtract. 
            //These are IV = 5 - 1 = 4; IX = 10 - 1 = 9; XL = 50 - 10 = 40; 
            // XC = 100 - 10 = 90; CD = 500 - 100 = 400; and CM = 1000 - 100 = 900
            
            //Another useful IMPORTANT information found on a site is that two subtractive numerals can not be adjacent such as:
            // CDCM since CM is higher however   CM CD is also invalid (range is 100-900)
            
            // The following is invalid:   IXIV even though IV is smaller than IX. This is because they are both in same range 1-9
            // In that respect,   XC XL is invalid..  both notations are  10-90
            // XCIV is ok
            
            //{'M','D','C','L','X', 'V','I'};
            
            // I have partially implemented the rule here since it is too complex.
        
        String IV =  "IV";
        String IX =  "IX";
        String XL =  "XL";
        String XC =  "XC";
        String CD=   "CD"; 
        String CM=   "CM";
        
        String [] subtractiveNumerals =  new String []{IV,IX,XL,XC,CD,CM};
        
        int [][] subtractiveNumeralsRange = new int[6][2];
        
        subtractiveNumeralsRange[0][0] = 1;   subtractiveNumeralsRange[0][1] = 4;
        subtractiveNumeralsRange[1][0] = 1;   subtractiveNumeralsRange[1][1] = 9;
        subtractiveNumeralsRange[2][0] = 10;   subtractiveNumeralsRange[2][1] = 40;
        subtractiveNumeralsRange[3][0] = 10;   subtractiveNumeralsRange[3][1] = 90;
        subtractiveNumeralsRange[4][0] = 100;   subtractiveNumeralsRange[4][1] = 500;
        subtractiveNumeralsRange[5][0] = 100;   subtractiveNumeralsRange[5][1] = 900;
        
        
        int sum1=0;
        int total1=0;
        boolean flagError=false;
        
        boolean result=false;
        int total2=0;
        
        int overallTotal=0;
        boolean twoSubtractiveNotations=false;
        boolean singleSubtractiveNotations=false;
        
        boolean rule2State=false;
        
        int rule2=0;
        int rule2total;
        boolean invalidSubtractiveNumeral=false;
        int temp=0;
        
        //-----------------------------------------
        
        // This has been completed outside main loop because it is processing a string to check values
        // this needs to go inside main loop. otherwise can not check the index of posValues
        
        System.out.println("In rule 4");
        for (int i=0; i<subtractiveNumerals.length; i++)   // this is going through all 6 combos IV, IX, XL.....
        {
            for (int j=0; j<subtractiveNumerals.length; j++ )   // this is going through all 6 combos IV, IX, XL.....
            {
                // NEED MORE LOGIC TO PREVENT IT FROM COMPARING AGAINST ITSELF.
                // OTHERWISE IT WILL PREVENT SINGLE OCCURENCE OF SUBTRACTIVE NOTATION FROM BEING PROCESSED
                
                if (j==i)
                {
                    continue;
                }
                
                // this ensures that there are matches against two subtractive notations before processing
                if (numeralsToString.indexOf(subtractiveNumerals[i])!=-1 &&  numeralsToString.indexOf(subtractiveNumerals[j])!=-1) 
                {
                     twoSubtractiveNotations = true;
                     
                    
                    // this checks if subtractive notation lower value appears at index before higher subtractive notation
                    if (numeralsToString.indexOf(subtractiveNumerals[i]) < numeralsToString.indexOf(subtractiveNumerals[j]))
                    
                    {
                        System.out.println("Incorrect roman numeral. " +  subtractiveNumerals[i] + " should be after: " + subtractiveNumerals[j]);
                        
                           processedConversion[numeralsToString.indexOf(subtractiveNumerals[i])]=1;
                           temp = numeralsToString.indexOf(subtractiveNumerals[i]) + 1;
                           processedConversion[temp]=1;
                        
                    }
                
                
                // this now checks the subtractive notations in correct order
                
                if (numeralsToString.indexOf(subtractiveNumerals[i]) > numeralsToString.indexOf(subtractiveNumerals[j]))
                {
                    //Both these subtractive numerals appear. a case of now checking if range is same
                    
                System.out.println("This should print out start of the range:" + subtractiveNumeralsRange[i][0]);
                System.out.println("This should print out end of the range:" + subtractiveNumeralsRange[i][1]);
                System.out.println("This should print out start of the range:" + subtractiveNumeralsRange[j][0]);
                System.out.println("This should print out end of the range:" + subtractiveNumeralsRange[j][1]);
                    
                    if (subtractiveNumeralsRange[i][0] == subtractiveNumeralsRange[j][0])  // these subtractive notations are in the same range
                    {
                        System.out.println(subtractiveNumerals[i] + " is in the range: " + subtractiveNumeralsRange[i][0] + " - " + subtractiveNumeralsRange[i][1]); 
                        System.out.println(subtractiveNumerals[j] + " is in the range: " + subtractiveNumeralsRange[j][0] + " - " + subtractiveNumeralsRange[j][1]);
                        System.out.println("They are both in the same range");
                        
                        
                        System.out.println("not sure whats here:" + subtractiveNumerals[i] + "  "+ numeralsToString.indexOf(subtractiveNumerals[i]));
                        System.out.println("not sure whats here:" + subtractiveNumerals[j] + "  "+ numeralsToString.indexOf(subtractiveNumerals[i+1]));
                        
                        System.out.println("not sure whats here:" + numeralsToString.indexOf(subtractiveNumerals[j]));
                         System.out.println("not sure whats here:" + numeralsToString.indexOf(subtractiveNumerals[j]+1));
                        
                        
                        processedConversion[numeralsToString.indexOf(subtractiveNumerals[i])]=1;
                        temp = numeralsToString.indexOf(subtractiveNumerals[i]) + 1;
                        processedConversion[temp]=1;
                        processedConversion[numeralsToString.indexOf(subtractiveNumerals[j])]=1;
                        temp = numeralsToString.indexOf(subtractiveNumerals[j]) + 1;
                        processedConversion[temp]=1;
                        
                        rule4=0;
                        
                    }
                    
                    if (subtractiveNumeralsRange[i][0] != subtractiveNumeralsRange[j][0])  // this ensures that subtractive notations are not in the same range
                    {
                        
                        if(processedConversion[numeralsToString.indexOf(subtractiveNumerals[i])]!=1 && processedConversion[numeralsToString.indexOf(subtractiveNumerals[j])]!=1 )
                        {
                    
                    if (numeralsToString.indexOf(subtractiveNumerals[i])!=-1 &&  numeralsToString.indexOf(subtractiveNumerals[j])!=-1)
                    {
                        System.out.println("correct order");
                        correctOrder=true;
                        
                        processedConversion[numeralsToString.indexOf(subtractiveNumerals[i])]=1;
                        //System.out.println("This is value marked with 1: " +  posValues[processedConversion[numeralsToString.indexOf(subtractiveNumerals[i])][1]]);
                        
                        temp = numeralsToString.indexOf(subtractiveNumerals[i]) + 1;
                        processedConversion[temp]=1;
                        //System.out.println("This is value marked with 1: " +  posValues[processedConversion[numeralsToString.indexOf(subtractiveNumerals[i])+1][1]]);
                        
                        switch (subtractiveNumerals[i])
                        {
                            case "IV":
                                rule4 = rule4 + 4;
                                break;
                                
                            case "IX":
                                rule4 = rule4 + 9;
                                break;
                                
                            case "XL":
                                rule4 = rule4 + 40;
                                break;
                                
                            case "XC":
                                rule4 = rule4 + 90;
                                break;
                                
                            case "CD":
                                rule4 = rule4 + 400;
                                break;
                                
                            case "CM":
                                rule4 = rule4 + 900;
                                break;
                                
                            default:
                            invalidSubtractiveNumeral = true;
                        }
                        
                        switch (subtractiveNumerals[j])
                        {
                            case "IV":
                                rule4 = rule4 + 4;
                                break;
                                
                            case "IX":
                                rule4 = rule4 + 9;
                                break;
                                
                            case "XL":
                                rule4 = rule4 + 40;
                                break;
                                
                            case "XC":
                                rule4 = rule4 + 90;
                                break;
                                
                            case "CD":
                                rule4 = rule4 + 400;
                                break;
                                
                            case "CM":
                                rule4 = rule4 + 900;
                                break;
                                
                            default:
                            invalidSubtractiveNumeral = true;
                        }
                        
                    }
                    }
                }
                    
                }
                }
            }
            
            boolean correctOrder=false;
            System.out.println("total after rule4:" + rule4);
            // this confirms if a match is found.  -1 value is no match. 0 is a match.
            System.out.println(subtractiveNumerals[i] + "   " + numeralsToString.indexOf(subtractiveNumerals[i]));
            
            // this now is just simply going through all subtractive notations if there is no other existing 
            // this can not run if the above circumstance is true.
            
            if (!twoSubtractiveNotations)
            {
                if (numeralsToString.indexOf(subtractiveNumerals[i])!=-1)
                {
                    if (processedConversion[numeralsToString.indexOf(subtractiveNumerals[i])]!=1)
                    {
                    
                    //System.out.println("It should be here for cases like CM");
                    processedConversion[numeralsToString.indexOf(subtractiveNumerals[i])]=1;
                    //System.out.println("This is value marked with 1: " +  posValues[processedConversion[numeralsToString.indexOf(subtractiveNumerals[i])][1]]);
                    
                    temp = numeralsToString.indexOf(subtractiveNumerals[i]) + 1;
                    processedConversion[temp]=1;
                    //System.out.println("This is value marked with 1: " +  posValues[processedConversion[numeralsToString.indexOf(subtractiveNumerals[i]+1)][1]]);
                    
                        switch (subtractiveNumerals[i])
                        {
                            case "IV":
                                rule4Single = rule4Single + 4;
                                break;
                                
                            case "IX":
                                rule4Single = rule4Single + 9;
                                break;
                                
                            case "XL":
                                rule4Single = rule4Single + 40;
                                break;
                                
                            case "XC":
                                rule4Single = rule4Single + 90;
                                break;
                                
                            case "CD":
                                rule4Single = rule4Single + 400;
                                break;
                                
                            case "CM":
                                rule4Single = rule4Single + 900;
                                break;
                            
                            default:
                            invalidSubtractiveNumeral = true;
                        }
                        
                        System.out.println("Does it even get here");
                        
                        
                       
                        //System.out.println("This should now print out instances like: " + numeralsToString);
                        System.out.println("It's conversion is:" +rule4Single);
                        twoSubtractiveNotations=false;
                        singleSubtractiveNotations=true;
                }
            }
            
            //if (numeralsToString.indexOf(subtractiveNumerals[i])==-1)
               // {
                    
              //      rule5=0;
                    
                //    System.out.println(numeralsToString + " has an illegal combination of subtractive notations");
                    
                //}
            
            }
        }
       
        //----------------------------------------------------------------
            
        //}
    //}
        //  MAIN PROGRAM EXECUTION
        //this will examine decimal number stored. If identical numerals in consecutive it will add to the total.
        
        for (int m=1; m<posValues.length; m++)  // this is starting not at zero index since compared to previous value
        {
            //if (processedConversion[m]!=1)
            //{
             //posValues[m][0]=numeral position     //[m][1]=decimal
            // This section is best completed examining string of the character array of inputted numerals.
            
            // Rule 3: The letters V, L, and D are not repeated.
            // There are acceptedNumerals[1], acceptedNumerals[3], acceptedNumerals[5]
            // posValues[m][0] stores information relevant
            
            //{'M','D','C','L','X', 'V','I'};
            
            System.out.println("Going into rule 3");
            
            //do
            //{
            if (!VLDcheck)
            {
            for (indexCount=0; indexCount<posValues.length; indexCount++)
            {
                System.out.println("value of indexCount: " + indexCount);
                System.out.println(posValues.length);
                
            if (posValues[indexCount][1]==5)
            {
                countV++;
                System.out.println("found a V");
            }
            
            if (posValues[indexCount][1]==50)
            {
                countL++;
            }
            
            if (posValues[indexCount][1]==500)
            {
                System.out.println("What is position of D: " + posValues[indexCount][1]);
                
                countD++;
            }
            
            
            //System.out.println("hat is indexCount this point: " + indexCount);
            //System.out.println("hat is posValues this point: " + posValues.length);
            
            //}while(indexCount<posValues.length);
            }
        }
            
           VLDcheck=true;
            
            
                //Rule 1: When certain numerals are repeated, the number represented by them is their sum. For example, II = 1 + 1 = 2, or XX = 10 + 10 = 20, or, XXX = 10 + 10 + 10 = 30.
                
                if (posValues[m][1]==posValues[m-1][1])   // this is comparing decimal number for numeral against previous one
                {
                    
                 // Rule 2: It is to be noted that no Roman numerals can come together more than 3 times. For example, we cannot write 40 as XXXX
                 System.out.println("starting rule 1");
                 //if (m!=(posValues.length-2) && posValues.length>3)   // what does this rule mean, first part
                 
                 if (posValues.length>2)
                 
                 
                 // m is current position in the numerals array
                 
                    {
                        
                    if (m!=posValues.length)
                    {
                    
                    // UNKNOWN ERROR
                    
                    System.out.println("start of rule2");
                    
                    if (m+2<posValues.length)
                    {
                    
                    if (posValues[m-1][1]==posValues[m][1] && posValues[m][1]==posValues[m+1][1] && posValues[m][1]==posValues[m+2][1])
                    {
                        System.out.println("There are more than three consecutive same characters: " + acceptedNumerals[posValues[m][0]]);
                        System.out.println("This is invalid roman numeral");
                        break;
                        //System.exit(0);
                    }
                    }
                    
                    }
                }
                    rule2total=posValues[m][1]+posValues[m-1][1];  
                    
                    
                    rule2=rule2+rule2total;    // they will be totalled if same
                    System.out.println("So far sum:" + rule2);
                    rule2State=true;
                    
                     processedConversion[m]=1;
                     processedConversion[m-1]=1;
                    
                    valueConsecutiveOccurences[m] = posValues[m][1];  //storing decimal value in array.
                    
                    consecutiveOccurrences=consecutiveOccurrences+2;
                    
                    // valueConsecutiveOccurences[m] this keeps a track of the roman numeral that has been repeating
                    //num++;
                   
                    // this checks if there has already been consecutive occurence of the numeral adjacently
                    //[m][0]=numeral position     //[m][1]=decimal
                    
                    if (m!=(posValues.length-1))
                    {
                                            
                    if (valueConsecutiveOccurences[m]==posValues[m+1][1])
                    {
                        
                        System.out.println("does this happen");
                        rule2=rule2-(rule2total/2);
                        //System.out.println("sum so far: " + sum);
                        rule2total=0;
                        processedConversion[m+1]=1;
                        
                    }
                }
                }
                //Rule 5: When a Roman numeral is placed after another Roman numeral of greater value, 
                //the result is the sum of the numerals. For example, VIII = 5 + 1 + 1 + 1 = 8, or, 
                //XV = 10 + 5 = 15,
                // This appears to be where the code has determined if numerals are in some decent order
                
                System.out.println("What is value of zeroindexcount: " + zeroIndexCount);
                
                if (posValues[m][1]<posValues[m-1][1])
                {
                    System.out.println("What is m: " + posValues[m][1]);
                    System.out.println("What is m-1: " + posValues[m-1][1]);
                   
                    processedConversion[m]=1;
                    //System.out.println("This is value marked with 1: " +  posValues[processedConversion[numeralsToString.indexOf(subtractiveNumerals[m])][1]]);
                    processedConversion[m-1]=1;
                    
                    //System.out.println("This is value marked with 1: " +  posValues[processedConversion[numeralsToString.indexOf(subtractiveNumerals[m])-1][1]]);
                    
                    rule5total = posValues[m][1] + posValues[m-1][1];
                    rule5 = rule5total + rule5;
                    rule5total = 0;
                    rule5State=true;
                    
                    if (m!=1)   // if not the first numeral
                    {
                    if (processedConversion[m-2]==1 && posValues[m-2][1]!=posValues[m][1])
                    {
                        System.out.println("What gets printed here: " + posValues[m-2][1]);
                        rule5=0;
                        //rule5total = 0;
                        rule5total = posValues[m][1] + posValues[m-1][1] + posValues[m-2][1];
                        rule5 = rule5total + rule5;
                        rule5total = 0;
                        rule5State=true;
                        
                    }
                    //else
                    //{
                      //  System.out.println("Roman numeral in same range");
                        //rule5=0;
                        
                    //}
                }
                    
                }
                System.out.println("at rule 6: " + total1);
                
               //Rule 6: When a Roman numeral is placed before another Roman numeral of greater value, 
               //the result is the difference between the numerals. For example, IV = 5 - 1 = 4, or, XL = 50 - 10 = 40, 
               //or XC = 100 - 10 = 90
                
                System.out.println("Rule 6");
                
                if (posValues[zeroIndexCount][1]<posValues[zeroIndexCount+1][1])
                {
                    if (posValues[zeroIndexCount][1]!=5 && posValues[zeroIndexCount][1]!=50 && posValues[zeroIndexCount][1]!=500)
                    
                    {
                        System.out.println("what are in here exactly:" + posValues[zeroIndexCount][1]);
                        
                        System.out.println("what are in here exactly:" + posValues[zeroIndexCount+1][1]);
                  
                    processedConversion[zeroIndexCount]=1;
                    
                    rule6total = posValues[zeroIndexCount+1][1] - posValues[zeroIndexCount][1];
                    rule6 = rule6total + rule6;
                    rule6total = 0;
                    rule6State=true;
                }
                
                else
                {   System.out.println("Illegal subtractive notation found with V, D or L");
                    rule5=0;
                }
                }
                
               // Rule 7: When a Roman numeral of a smaller value is placed between two numerals of greater value, 
               //it is subtracted from the numeral on its right. For example, XIV = 10 + (5 - 1) = 14, 
               //or, XIX = 10 + (10 - 1) = 19
                
                System.out.println("Rule 7");
                // rule 7 will not stall by rule 4  since the the right hand side character in rule 4 is always bigger.
                
                if (m!=posValues.length && posValues.length>2) // a numeral can not be in middle if it is the last in the numeral array
                // it also can not be in middle if the first numeral. Hence using m index notation.
                
                {
                    if (processedConversion[m]!=1)
                    {
                    
                    //START FROM HERE AND TEST  XI
                
                if (m!=posValues.length-1)
                {
                    
                if (posValues[m][1]<posValues[m-1][1] && posValues[m][1]<posValues[m+1][1])
                {
                    
                    //System.out.println("what " + (m-1));
                    
                    processedConversion[m]=1;
                    //System.out.println("This is value marked with 1: " +  posValues[processedConversion[numeralsToString.indexOf(subtractiveNumerals[m])][1]]);
                    processedConversion[m+1]=1;
                    //System.out.println("This is value marked with 1: " +  posValues[processedConversion[numeralsToString.indexOf(subtractiveNumerals[m+1])][1]]);
                    
                    rule7total = posValues[m+1][1] - posValues[m][1];
                    rule7 = rule7total + rule7;
                    rule7total = 0;
                    
                    System.out.println("total at rule 7:" + rule7);
                    
                    }
                    
                }
                
                }
            }
                zeroIndexCount++;
                
                System.out.println("This is overall total:" + (total1));
       // }
    }
        
        
        // THIS WILL NOW CHECK IF EACH NUMBER HAS OR HAS NOT BEEN PROCESSED IN CHECKING SO far
        
        int counter=0;
        int unTotal=0;
        
        for (int c: processedConversion)
        {
            System.out.println("This is value of c: " + c);
            System.out.println("This is the numeral value: " + posValues[counter][1]);
            
            if (c!=1)
            {
                unTotal = posValues[counter][1] + unTotal;
                System.out.println("This has not been added to the total" + unTotal);
                System.out.println("This is the position: " + counter);
            }
            
            counter++;
        }
        
            // this is part of rule 3
            
            if (countD>1 || countL>1 || countV>1)
            {
                System.out.println("Invalid roman numeral. Numeral V or D or L has occured more than once");
                rule3Fail = true;
            }
            
             if (inputtedNumerals.length==2)  // checking number with 2 numerals
        {
            if (posValues[0][0]==posValues[1][0] && rule3Fail==false)  // if values identical straight forward conversion
            {
                twoNumerals = posValues[0][1] + posValues[1][1];
                
                
            System.out.println("Conversion is double:" + (twoNumerals));
            
            //System.out.println("XL: " +  posValues[0][1]);
            processedConversion[0]=1;
            
            processedConversion[1]=1;
            //System.out.println("This is value marked with 1: " +  posValues[1][1]);
            
            
            }
        }
        
        System.out.println("Frequency of V: " + countV);
        System.out.println("Frequency of L: " + countL);
        System.out.println("Frequency  of D: " + countD);
        
        System.out.println("rule4: " + rule4);
        System.out.println("unTotal: " + unTotal);
        System.out.println("rule2: " + rule2);
        System.out.println("rule4Single: " + rule4Single);
        System.out.println("rule5: " + rule5);
        System.out.println("rule6: " + rule6);
        System.out.println("rule7: " + rule7);
        
        
        if(rule3Fail)
        {
            System.out.println("Total1 is: " + 0);
            System.exit(0);
        }
        
        if (rule2!=0 && twoNumerals==0)
            {
                System.out.println("Total1 is: " + (rule2));
                System.exit(0);
            }
        
        
          if(rule4!=0)
        {
            System.out.println("Total3 is: " + (rule4));
            System.exit(0);
        }
        
        if(unTotal!=0 && rule4Single!=0)
        {
            System.out.println("Total3 is: " + (unTotal + rule4Single));
            System.exit(0);
        }
        
         if(unTotal!=0)
        {
            System.out.println("Total3 is: " + (rule5));
            System.exit(0);
        }
        
        
        if (rule3Fail)
            {
                System.out.println("More than 2 instances of V, L and D:");
                System.out.println("D: " + countD);
                System.out.println("V: " + countV);
                System.out.println("L: " + countL);
                System.exit(0);
            }
            
            
              if (rule5!=0)
            {
                System.out.println("Total3 is: " + (rule5));
                System.exit(0);
            }
            
            if (rule5State && rule2!=0 && rule5!=0)
            {
                 System.out.println("Total should function is: " + (rule5 + (rule2/2)));
                System.exit(0);
                
            }
            
            
        
           
         
            if (rule4Single!=0)
            {
                System.out.println("Total4 is: " + (unTotal + rule4Single));
                System.exit(0);
            }
            
         
        
        //System.out.println("this is the overall sum: " + (rule2+rule4Single+rule5+rule6+rule7));
       // System.out.println("this is the overall sum: " + (rule5 + rule2));
        
        // This is the best logic found on the internet for roman numeral conversion.
        // Logic will be coded one by one and see if it works overall
    /*
    
    It is necessary for us to remember the rules for reading and writing Roman numbers in order to avoid mistakes. Here is a list of the basic rules for Roman numerals.

    Rule 1: When certain numerals are repeated, the number represented by them is their sum. For example, II = 1 + 1 = 2, or XX = 10 + 10 = 20, or, XXX = 10 + 10 + 10 = 30.
    Rule 2: It is to be noted that no Roman numerals can come together more than 3 times. For example, we cannot write 40 as XXXX
    Rule 3: The letters V, L, and D are not repeated.
    Rule 4: Only I, X, and C can be used as subtractive numerals. There can be 6 combinations when we subtract. These are IV = 5 - 1 = 4; IX = 10 - 1 = 9; XL = 50 - 10 = 40; XC = 100 - 10 = 90; CD = 500 - 100 = 400; and CM = 1000 - 100 = 900
    Rule 5: When a Roman numeral is placed after another Roman numeral of greater value, the result is the sum of the numerals. For example, VIII = 5 + 1 + 1 + 1 = 8, or, XV = 10 + 5 = 15,
    Rule 6: When a Roman numeral is placed before another Roman numeral of greater value, the result is the difference between the numerals. For example, IV = 5 - 1 = 4, or, XL = 50 - 10 = 40, or XC = 100 - 10 = 90
    Rule 7: When a Roman numeral of a smaller value is placed between two numerals of greater value, it is subtracted from the numeral on its right. For example, XIV = 10 + (5 - 1) = 14, or, XIX = 10 + (10 - 1) = 19
    Rule 8: To multiply a number by a factor of 1000 a bar is placed over it.
    Rule 9: Roman numerals do not follow any place value system.
    Rule 10: There is no Roman numeral for zero (0).
*/
        
    }
   
}