# -*- coding: utf-8 -*-
from rules import *
from panic_detail import PanicDetail


class CallTraceStatus:
    IN_NMI, IN_IRQ, IN_TASK, NOTIN = range(4)


class RegStatus:
    IN_SHOW_REGS, NOTIN = range(2)


class LogParser:
    def __init__(self):
        self.calltrace_status = CallTraceStatus.NOTIN
        self.regs_status = RegStatus.NOTIN
        self.last_calltrace_ts = None

    def parse_file(self, file):
        with open(file, "r") as f:
            return self.parse_log(f.read())

    def set_calltrace_status(self, flag):
        if flag == TagLineRules.ENTER_CALLTRACE:
            self.calltrace_status = CallTraceStatus.IN_TASK
        if flag == TagLineRules.ENTER_IRQ:
            self.calltrace_status = CallTraceStatus.IN_IRQ
        elif flag == TagLineRules.ENTER_NMI:
            self.calltrace_status = CallTraceStatus.IN_NMI
        elif flag == TagLineRules.EXIT_STACK:
            self.calltrace_status = CallTraceStatus.IN_TASK

    def parse_log(self, log):
        detail = PanicDetail()

        for line in log.split("\n"):
            if Rule.base.match(line):
                detail.panic_ts = Rule.base.extract_time(line)
            else:
                continue

            if Rule.boot_info.match(line):
                detail.set_version(Rule.boot_info.extract_version(line))
            elif self.regs_status == RegStatus.IN_SHOW_REGS and Rule.rip.match(line):
                detail.rip = Rule.rip.extract_rip(line)
                detail.func_name = Rule.rip.extract_function(line)
                detail.rip_mod = Rule.rip.extract_module(line)
            elif Rule.title.match(line):
                detail.title = Rule.title.extract_title(line)
            elif Rule.error_log.match(line):
                detail.error_dmesg.append(line)
            elif Rule.panic_info.match(line):
                detail.comm = Rule.panic_info.extract_comm(line)
                detail.cpu = Rule.panic_info.extract_cpu(line)
                detail.set_version(Rule.panic_info.extract_version(line))
                self.regs_status = RegStatus.IN_SHOW_REGS
                detail.clear_rip()
            elif Rule.modules.match(line):
                detail.modules = Rule.modules.extract_modules(line)
            if Rule.tag.match(line):
                flags = Rule.tag.extract_tags(line)
                for flag in flags:
                    self.set_calltrace_status(flag)
                    if flag == TagLineRules.ENTER_CALLTRACE:
                        self.last_calltrace_ts = Rule.tag.extract_time(line)
                        # if we meet a new calltrace，then we need to save the previous calltrace
                        detail.error_dmesg.extend(detail.stack)
                        detail.clear_stack()
                detail.stack.append(line)
            if Rule.function.match(line):
                detail.stack.append(line)
                if Rule.function.match_valid_function(line):
                    function, module = Rule.function.extract_function(
                        line
                    ), Rule.function.extract_module(line)
                    frame = (function, module)

                    if self.calltrace_status == CallTraceStatus.IN_TASK:
                        detail.task_stack.append(frame)
                    elif self.calltrace_status == CallTraceStatus.IN_IRQ:
                        detail.irq_stack.append(frame)
                    elif self.calltrace_status == CallTraceStatus.IN_NMI:
                        detail.nmi_stack.append(frame)
        if (
            detail.panic_ts
            and self.last_calltrace_ts
            and detail.panic_ts - self.last_calltrace_ts > 60
        ):
            # if the calltrace is not in the last 60 seconds, then it is not a panic calltrace
            detail.clear_stack()
            detail.error_dmesg.extend(detail.stack)

        detail.refine_error_log()
        return detail