# Copyright (c) Barefoot Networks, Inc.
# Licensed under the Apache License, Version 2.0 (the "License")

from collections import defaultdict, OrderedDict
from compilationException import CompilationException
from p4_hlir.hlir import parse_call, p4_field, p4_parse_value_set, \
    P4_DEFAULT, p4_parse_state, p4_table, \
    p4_conditional_node, p4_parser_exception, \
    p4_header_instance, P4_NEXT

import ebpfProgram
import ebpfInstance
import ebpfType
import ebpfStructType
from topoSorting import Graph
from programSerializer import ProgramSerializer

def produce_parser_topo_sorting(hlir):
    # This function is copied from the P4 behavioral model implementation
    header_graph = Graph()

    def walk_rec(hlir, parse_state, prev_hdr_node, tag_stacks_index):
        assert(isinstance(parse_state, p4_parse_state))
        for call in parse_state.call_sequence:
            call_type = call[0]
            if call_type == parse_call.extract:
                hdr = call[1]

                if hdr.virtual:
                    base_name = hdr.base_name
                    current_index = tag_stacks_index[base_name]
                    if current_index > hdr.max_index:
                        return
                    tag_stacks_index[base_name] += 1
                    name = base_name + "[%d]" % current_index
                    hdr = hlir.p4_header_instances[name]

                if hdr not in header_graph:
                    header_graph.add_node(hdr)
                hdr_node = header_graph.get_node(hdr)

                if prev_hdr_node:
                    prev_hdr_node.add_edge_to(hdr_node)
                else:
                    header_graph.root = hdr
                prev_hdr_node = hdr_node

        for branch_case, next_state in parse_state.branch_to.items():
            if not next_state:
                continue
            if not isinstance(next_state, p4_parse_state):
                continue
            walk_rec(hlir, next_state, prev_hdr_node, tag_stacks_index.copy())

    start_state = hlir.p4_parse_states["start"]
    walk_rec(hlir, start_state, None, defaultdict(int))

    header_topo_sorting = header_graph.produce_topo_sorting()

    return header_topo_sorting

class EbpfDeparser(object):
    def __init__(self, hlir):
        header_topo_sorting = produce_parser_topo_sorting(hlir)
        self.headerOrder = [hdr.name for hdr in header_topo_sorting]

    def serialize(self, serializer, program):
        assert isinstance(serializer, ProgramSerializer)
        assert isinstance(program, ebpfProgram.EbpfProgram)

        serializer.emitIndent()
        serializer.blockStart()
        serializer.emitIndent()
        serializer.appendLine("/* Deparser */")
        serializer.emitIndent()
        serializer.appendFormat("{0} = 0;", program.offsetVariableName)
        serializer.newline()
        for h in self.headerOrder:
            header = program.getHeaderInstance(h)
            self.serializeHeaderEmit(header, serializer, program)
        serializer.blockEnd(True)

    def serializeHeaderEmit(self, header, serializer, program):
        assert isinstance(header, ebpfInstance.EbpfHeader)
        assert isinstance(serializer, ProgramSerializer)
        assert isinstance(program, ebpfProgram.EbpfProgram)
        p4header = header.hlirInstance
        assert isinstance(p4header, p4_header_instance)

        serializer.emitIndent()
        serializer.appendFormat("if ({0}.{1}.valid) ",
                                program.headerStructName, header.name)
        serializer.blockStart()

        if ebpfProgram.EbpfProgram.isArrayElementInstance(p4header):
            ebpfStack = program.getStackInstance(p4header.base_name)
            assert isinstance(ebpfStack, ebpfInstance.EbpfHeaderStack)

            if isinstance(p4header.index, int):
                index = "[" + str(p4header.index) + "]"
            elif p4header.index is P4_NEXT:
                index = "[" + ebpfStack.indexVar + "]"
            else:
                raise CompilationException(
                    True, "Unexpected index for array {0}",
                    p4header.index)
            basetype = ebpfStack.basetype
        else:
            ebpfHeader = program.getHeaderInstance(p4header.name)
            basetype = ebpfHeader.type
            index = ""

        alignment = 0
        for field in basetype.fields:
            assert isinstance(field, ebpfStructType.EbpfField)

            self.serializeFieldEmit(serializer, p4header.base_name,
                                    index, field, alignment, program)
            alignment += field.widthInBits()
            alignment = alignment % 8
        serializer.blockEnd(True)

    def serializeFieldEmit(self, serializer, name, index,
                           field, alignment, program):
        assert isinstance(index, str)
        assert isinstance(name, str)
        assert isinstance(field, ebpfStructType.EbpfField)
        assert isinstance(serializer, ProgramSerializer)
        assert isinstance(alignment, int)
        assert isinstance(program, ebpfProgram.EbpfProgram)

        if field.name == "valid":
            return

        fieldToEmit = (program.headerStructName + "." + name +
                       index + "." + field.name)
        width = field.widthInBits()
        if width <= 32:
            store = self.generatePacketStore(fieldToEmit, 0, alignment,
                                             width, program)
            serializer.emitIndent()
            serializer.appendLine(store)
        else:
            # Destination is bigger than 4 bytes and
            # represented as a byte array.
            b = (width + 7) / 8
            for i in range(0, b):
                serializer.emitIndent()
                store = self.generatePacketStore(fieldToEmit + "["+str(i)+"]",
                                                 i,
                                                 alignment,
                                                 8, program)
                serializer.appendLine(store)

        serializer.emitIndent()
        serializer.appendFormat("{0} += {1};",
                                program.offsetVariableName, width)
        serializer.newline()

    def generatePacketStore(self, value, offset, alignment, width, program):
        assert width > 0
        assert alignment < 8
        assert isinstance(width, int)
        assert isinstance(alignment, int)

        return "bpf_dins_pkt({0}, {1} / 8 + {2}, {3}, {4}, {5});".format(
            program.packetName,
            program.offsetVariableName,
            offset,
            alignment,
            width,
            value
        )
