#include "readDefaultPattern.h"
#include "sls_detector_defs.h"
#include "slsDetectorServer_defs.h"
#include "ansi.h"
#include "clogger.h"

#include <string.h>

extern char initErrorMessage[MAX_STR_LENGTH];
extern int initError;

extern uint64_t writePatternIOControl(uint64_t word);
extern uint64_t writePatternClkControl(uint64_t word);
extern uint64_t writePatternWord(int addr, uint64_t word);
extern int setPatternWaitAddress(int level, int addr);
extern uint64_t setPatternWaitTime(int level, uint64_t t);
extern void setPatternLoop(int level, int *startAddr, int *stopAddr, int *nLoop);


int	loadDefaultPattern(char* fname) {
	if (initError == FAIL) {
		return initError;
	}

    FILE* fd = fopen(fname, "r");
    if(fd == NULL) {
		sprintf(initErrorMessage, "Could not open pattern file [%s].\n", fname);
		initError = FAIL;		
		FILE_LOG(logERROR, ("%s\n\n", initErrorMessage));
        return FAIL;
    }
    FILE_LOG(logINFOBLUE, ("Reading default pattern file %s\n", fname));


    // Initialization
    const size_t LZ = 256;
    char line[LZ];
    memset(line, 0, LZ);
    char command[LZ];

    // keep reading a line
    while (fgets(line, LZ, fd)) {

		// ignore comments
        if (line[0] == '#') {
			FILE_LOG(logDEBUG1, ("Ignoring Comment\n"));
            continue;
		}

		// ignore empty lines
		if (strlen(line) <= 1) {
			FILE_LOG(logDEBUG1, ("Ignoring Empty line\n"));
			continue;
		}

		FILE_LOG(logDEBUG1, ("Command to process: (size:%d) %.*s\n", 
            strlen(line), strlen(line) -1, line));
		memset(command, 0, LZ);

        // patword
		if (!strncmp(line, "patword", strlen("patword"))) {
            uint32_t addr = 0;
            uint64_t word = 0;

			// cannot scan values
			if (sscanf(line, "%s 0x%x 0x%llx", command, &addr, &word) != 3) {
				sprintf(initErrorMessage, "Could not scan patword arguments from default "
                    "pattern file. Line:[%s].\n", line);
				break;
			}	

            if (default_writePatternWord(line, addr, word) == FAIL) {
                break;
            }
        }

        // patioctrl
 		if (!strncmp(line, "patioctrl", strlen("patioctrl"))) {
            uint64_t arg = 0;

			// cannot scan values
			if (sscanf(line, "%s 0x%llx", command, &arg) != 2) {
				sprintf(initErrorMessage, "Could not scan patioctrl arguments from default "
                    "pattern file. Line:[%s].\n", line);
				break;
			}	

            if (default_writePatternIOControl(line, arg) == FAIL) {
                break;
            }
        }

        // patclkctrl
 		if (!strncmp(line, "patclkctrl", strlen("patclkctrl"))) {
            uint64_t arg = 0;

			// cannot scan values
			if (sscanf(line, "%s 0x%llx", command, &arg) != 2) {
				sprintf(initErrorMessage, "Could not scan patclkctrl arguments from default "
                    "pattern file. Line:[%s].\n", line);
				break;
			}	

            if (default_writePatternClkControl(line, arg) == FAIL) {
                break;
            }
        }

        // patlimits
		if (!strncmp(line, "patlimits", strlen("patlimits"))) {
            uint32_t startAddr = 0;
            uint32_t stopAddr = 0;

			// cannot scan values
			if (sscanf(line, "%s 0x%x 0x%x", command, &startAddr, &stopAddr) != 3) {
				sprintf(initErrorMessage, "Could not scan patlimits arguments from default "
                    "pattern file. Line:[%s].\n", line);
				break;
			}	

            if (default_setPatternLoopLimits(line, startAddr, stopAddr) == FAIL) {
                break;
            }
        }

        // patloop
		if ((!strncmp(line, "patloop0", strlen("patloop0"))) ||
            (!strncmp(line, "patloop1", strlen("patloop1"))) ||
            (!strncmp(line, "patloop2", strlen("patloop2")))) {
            
            // level
            int level = -1;
            if (!strncmp(line, "patloop0", strlen("patloop0"))) {
                level = 0;
            } else if (!strncmp(line, "patloop1", strlen("patloop1"))) {
                level = 1;
            } else {
                level = 2;
            }

            uint32_t startAddr = 0;
            uint32_t stopAddr = 0;
			// cannot scan values
			if (sscanf(line, "%s 0x%x 0x%x", command, &startAddr, &stopAddr) != 3) {
				sprintf(initErrorMessage, "Could not scan patloop%d arguments from default "
                    "pattern file. Line:[%s].\n", level, line);
				break;
			}	

            if (default_setPatternLoopAddresses(line, level, startAddr, stopAddr) == FAIL) {
                break;
            }
        }       

        // patnloop
		if ((!strncmp(line, "patnloop0", strlen("patnloop0"))) ||
            (!strncmp(line, "patnloop1", strlen("patnloop1"))) ||
            (!strncmp(line, "patnloop2", strlen("patnloop2")))) {
            
            // level
            int level = -1;
            if (!strncmp(line, "patnloop0", strlen("patnloop0"))) {
                level = 0;
            } else if (!strncmp(line, "patnloop1", strlen("patnloop1"))) {
                level = 1;
            } else {
                level = 2;
            }

            int numLoops = -1;
			// cannot scan values
			if (sscanf(line, "%s %d", command, &numLoops) != 2) {
				sprintf(initErrorMessage, "Could not scan patnloop%d arguments from default "
                    "pattern file. Line:[%s].\n", level, line);
				break;
			}	

            if (default_setPatternLoopCycles(line, level, numLoops) == FAIL) {
                break;
            }
        }  

        // patwait
		if ((!strncmp(line, "patwait0", strlen("patwait0"))) ||
            (!strncmp(line, "patwait1", strlen("patwait1"))) ||
            (!strncmp(line, "patwait2", strlen("patwait2")))) {

            // level
            int level = -1;
            if (!strncmp(line, "patwait0", strlen("patwait0"))) {
                level = 0;
            } else if (!strncmp(line, "patwait1", strlen("patwait1"))) {
                level = 1;
            } else {
                level = 2;
            }

            uint32_t addr = 0;
			// cannot scan values
			if (sscanf(line, "%s 0x%x", command, &addr) != 2) {
				sprintf(initErrorMessage, "Could not scan patwait%d arguments from default "
                    "pattern file. Line:[%s].\n", level, line);
				break;
			}	

            if (default_setPatternWaitAddresses(line, level, addr) == FAIL) {
                break;
            }
        }       

        // patwaittime
		if ((!strncmp(line, "patwaittime0", strlen("patwaittime0"))) ||
            (!strncmp(line, "patwaittime1", strlen("patwaittime1"))) ||
            (!strncmp(line, "patwaittime2", strlen("patwaittime2")))) {

            // level
            int level = -1;
            if (!strncmp(line, "patwaittime0", strlen("patwaittime0"))) {
                level = 0;
            } else if (!strncmp(line, "patwaittime1", strlen("patwaittime1"))) {
                level = 1;
            } else {
                level = 2;
            }

            uint64_t waittime = 0;

			// cannot scan values
			if (sscanf(line, "%s %lld", command, &waittime) != 2) {
				sprintf(initErrorMessage, "Could not scan patwaittime%d arguments from default "
                    "pattern file. Line:[%s].\n", level, line);
				break;
			}	

            if (default_setPatternWaitTime(line, level, waittime) == FAIL) {
                break;
            }
        } 

        memset(line, 0, LZ);
    }
    fclose(fd); 

	if (strlen(initErrorMessage)) {
		initError = FAIL;		
		FILE_LOG(logERROR, ("%s\n\n", initErrorMessage));
	} else {
		FILE_LOG(logINFOBLUE, ("Successfully read default pattern file\n"));
	}
    return initError;
}


int default_writePatternWord(char* line, uint32_t addr, uint64_t word) {
    //validations 
    if (addr < 0 || addr >= MAX_PATTERN_LENGTH) {
        sprintf(initErrorMessage, "Cannot set pattern word from default "
            "pattern file. Addr must be between 0 and 0x%x. Line:[%s]\n",
            MAX_PATTERN_LENGTH, line);
        return FAIL;
    }
    writePatternWord(addr, word);
    // cannot validate for moench, ctb ( same as executing pattern word)
    return OK;
}

int default_writePatternIOControl(char* line, uint64_t arg) {
    uint64_t retval = writePatternIOControl(arg);
    if (retval != arg) {
        sprintf(initErrorMessage, "Could not set patioctrl from default pattern "
            "file. Set 0x%llx, read 0x%llx. Line:[%s]\n", arg, retval, line);
        return FAIL;               
    }    
    return OK;
}


int default_writePatternClkControl(char* line, uint64_t arg) {
    uint64_t retval = writePatternClkControl(arg);
    if (retval != arg) {
        sprintf(initErrorMessage, "Could not set patclkctrl from default pattern "
            "file. Set 0x%llx, read 0x%llx. Line:[%s]\n", arg, retval, line);
        return FAIL;               
    }    
    return OK;
}

int default_setPatternLoopLimits(char* line, uint32_t startAddr, uint32_t stopAddr) {
    //validations 
    if (startAddr < 0 || startAddr >= MAX_PATTERN_LENGTH || 
        stopAddr < 0 || stopAddr >= MAX_PATTERN_LENGTH) {
        sprintf(initErrorMessage, "Cannot set patlimits from default "
            "pattern file. Addr must be between 0 and 0x%x. Line:[%s]\n", 
            MAX_PATTERN_LENGTH, line);
        return FAIL;
    } 
    int numLoops = -1;
    int r_startAddr = startAddr, r_stopAddr = stopAddr;
    setPatternLoop(-1, &r_startAddr, &r_stopAddr, &numLoops);

    // validate
    if (r_startAddr != startAddr || r_stopAddr != stopAddr) {
        sprintf(initErrorMessage, "Could not set patlimits from default pattern "
        "file. Read start addr:0x%x, stop addr: 0x%x. Line:[%s]\n", 
        r_startAddr, r_stopAddr, line);
        return FAIL;
    }                
    return OK;
}

int default_setPatternLoopAddresses(char* line, int level, uint32_t startAddr, uint32_t stopAddr) {
    //validations 
    if (level < 0 || level > 2) {
        sprintf(initErrorMessage, "Cannot set patloop from default "
            "pattern file. Level must be between 0 and 2. Line:[%s]\n", 
            line);
        return FAIL;
    }
    if (startAddr < 0 || startAddr >= MAX_PATTERN_LENGTH || 
        stopAddr < 0 || stopAddr >= MAX_PATTERN_LENGTH) {
        sprintf(initErrorMessage, "Cannot set patloop (level: %d) from default "
            "pattern file. Addr must be between 0 and 0x%x. Line:[%s]\n", 
            level, MAX_PATTERN_LENGTH, line);
        return FAIL;
    } 
    int numLoops = -1;
    int r_startAddr = startAddr, r_stopAddr = stopAddr;
    setPatternLoop(level, &r_startAddr, &r_stopAddr, &numLoops);

    // validate
    if (r_startAddr != startAddr || r_stopAddr != stopAddr) {
        sprintf(initErrorMessage, "Could not set patloop (level: %d) from default "
        "pattern file. Read start addr:0x%x, stop addr: 0x%x. Line:[%s]\n", 
        level, r_startAddr, r_stopAddr, line);
        return FAIL;
    }                
    return OK;  
}

int default_setPatternLoopCycles(char* line, int level, int numLoops) {
     //validations 
    if (level < 0 || level > 2) {
        sprintf(initErrorMessage, "Cannot set patnloop from default "
            "pattern file. Level must be between 0 and 2. Line:[%s]\n", 
            line);
        return FAIL;
    }
    if (numLoops < 0) {
        sprintf(initErrorMessage, "Cannot set patnloop from default "
            "pattern file. Iterations must be between > 0. Line:[%s]\n", 
            line);
        return FAIL;        
    }
    int startAddr = -1;
	int stopAddr = -1;
    int r_numLoops = numLoops;
    setPatternLoop(level, &startAddr, &stopAddr, &r_numLoops);

    // validate
    if (r_numLoops != numLoops) {
        sprintf(initErrorMessage, "Could not set patnloop (level: %d) from default "
        "pattern file. Read %d loops. Line:[%s]\n", 
        level, r_numLoops, line);
        return FAIL;
    }  
    return OK;  
}

int default_setPatternWaitAddresses(char* line, int level, uint32_t addr) {
    //validations 
    if (level < 0 || level > 2) {
        sprintf(initErrorMessage, "Cannot set patwait address from default "
            "pattern file. Level must be between 0 and 2. Line:[%s]\n", 
            line);
        return FAIL;
    }
    if (addr < 0 || addr >= MAX_PATTERN_LENGTH) {
        sprintf(initErrorMessage, "Cannot set patwait address (level: %d) from default "
            "pattern file. Addr must be between 0 and 0x%x. Line:[%s]\n", 
            level, MAX_PATTERN_LENGTH, line);
        return FAIL;
    } 

    int retval = setPatternWaitAddress(level, addr);

    // validate
    if (retval != addr) {
        sprintf(initErrorMessage, "Could not set patwait address (level: %d) from default "
        "pattern file. Read addr: 0x%x. Line:[%s]\n", 
        level, retval, line);
        return FAIL;
    }                
    return OK;  
}

int default_setPatternWaitTime(char* line, int level, uint64_t waittime) {
     //validations 
    if (level < 0 || level > 2) {
        sprintf(initErrorMessage, "Cannot set patwaittime from default "
            "pattern file. Level must be between 0 and 2. Line:[%s]\n", 
            line);
        return FAIL;
    }
    uint64_t retval = setPatternWaitTime(level, waittime);

    // validate
    if (retval != waittime) {
        sprintf(initErrorMessage, "Could not set patwaittime (level: %d) from default "
        "pattern file. Read %lld wait time. Line:[%s]\n", 
        level, retval, line);
        return FAIL;
    }  
    return OK;  
}