# Copyright lowRISC contributors.
# Licensed under the Apache License, Version 2.0, see LICENSE for details.
# SPDX-License-Identifier: Apache-2.0

# portions adapted from the javascript wavedrom.js
# https://github.com/drom/wavedrom/blob/master/wavedrom.js
# see LICENSE.wavedrom

import io
import logging as log

from wavegen import wavesvg_data

# Generate brick: follows wavedrom.js


def gen_brick(texts, extra, times):
    res = []

    # length of four indicates 2 phases each with 2 bricks
    if (len(texts) == 4):
        if extra != int(extra):
            log.error("Clock must have an integer period")
        for j in range(times):
            res.append(texts[0])
            for i in range(int(extra)):
                res.append(texts[1])
            res.append(texts[2])
            for i in range(int(extra)):
                res.append(texts[3])
        return res

    if (len(texts) == 1):
        t1 = texts[0]
    else:
        t1 = texts[1]

    res.append(texts[0])
    for i in range(times * int(2 * (extra + 1)) - 1):
        res.append(t1)
    return res


# Generate first brick in a line: follows wavedrom.js
def gen_first_wavebrick(text, extra, times):

    gentext = {
        'p': ['pclk', '111', 'nclk', '000'],
        'n': ['nclk', '000', 'pclk', '111'],
        'P': ['Pclk', '111', 'nclk', '000'],
        'N': ['Nclk', '000', 'pclk', '111'],
        'l': ['000'],
        'L': ['000'],
        '0': ['000'],
        'h': ['111'],
        'H': ['111'],
        '1': ['111'],
        '=': ['vvv-2'],
        '2': ['vvv-2'],
        '3': ['vvv-3'],
        '4': ['vvv-4'],
        '5': ['vvv-5'],
        'd': ['ddd'],
        'u': ['uuu'],
        'z': ['zzz']
    }
    return gen_brick(gentext.get(text, ['xxx']), extra, times)


# Generate subsequent bricks: text contains before and after states
# Follows wavedrom
def gen_wavebrick(text, extra, times):

    # new states that have a hard edge going in to them
    new_hardedges = {
        'p': 'pclk',
        'n': 'nclk',
        'P': 'Pclk',
        'N': 'Nclk',
        'h': 'pclk',
        'l': 'nclk',
        'H': 'Pclk',
        'L': 'Nclk'
    }

    # new state with a soft edge
    new_softedges = {
        '0': '0',
        '1': '1',
        'x': 'x',
        'd': 'd',
        'u': 'u',
        'z': 'z',
        '=': 'v',
        '2': 'v',
        '3': 'v',
        '4': 'v',
        '5': 'v'
    }

    # state we are coming from
    old_edges = {
        'p': '0',
        'n': '1',
        'P': '0',
        'N': '1',
        'h': '1',
        'l': '0',
        'H': '1',
        'L': '0',
        '0': '0',
        '1': '1',
        'x': 'x',
        'd': 'd',
        'u': 'u',
        'z': 'z',
        '=': 'v',
        '2': 'v',
        '3': 'v',
        '4': 'v',
        '5': 'v'
    }

    # tags (basically the colour) -- js had two arrays for this
    tags = {
        'p': '',
        'n': '',
        'P': '',
        'N': '',
        'h': '',
        'l': '',
        'H': '',
        'L': '',
        '0': '',
        '1': '',
        'x': '',
        'd': '',
        'u': '',
        'z': '',
        '=': '-2',
        '2': '-2',
        '3': '-3',
        '4': '-4',
        '5': '-5'
    }

    # drawing for the second half of the new state
    new_secondbricks = {
        'p': '111',
        'n': '000',
        'P': '111',
        'N': '000',
        'h': '111',
        'l': '000',
        'H': '111',
        'L': '000',
        '0': '000',
        '1': '111',
        'x': 'xxx',
        'd': 'ddd',
        'u': 'uuu',
        'z': 'zzz',
        '=': 'vvv-2',
        '2': 'vvv-2',
        '3': 'vvv-3',
        '4': 'vvv-4',
        '5': 'vvv-5'
    }

    phase2_firstbricks = {'p': 'nclk', 'n': 'pclk', 'P': 'nclk', 'N': 'pclk'}

    phase2_secondbricks = {'p': '000', 'n': '111', 'P': '000', 'N': '111'}

    xclude = {
        'hp': '111',
        'Hp': '111',
        'ln': '000',
        'Ln': '000',
        'nh': '111',
        'Nh': '111',
        'pl': '000',
        'Pl': '000'
    }

    secondbrick = new_secondbricks.get(text[1])
    hardbrick = new_hardedges.get(text[1])
    if hardbrick == None:
        # a soft edge gets the brick type constructed from the
        # old state, m, new state. Old and new states may have
        # tags which basically represent the colour
        newch = new_softedges.get(text[1])
        oldch = old_edges.get(text[0])
        if newch == None or oldch == None:
            # unknown: can't find the characters to make an edge
            return gen_brick(['xxx'], extra, times)
        else:
            # soft curves
            return gen_brick([
                oldch + 'm' + newch + tags[text[0]] + tags[text[1]],
                secondbrick
            ], extra, times)
    else:
        specialcase = xclude.get(text)
        if specialcase != None:
            hardbrick = specialcase

        # sharp curves
        twophase = phase2_firstbricks.get(text[1])
        if twophase == None:
            # hlHL
            return gen_brick([hardbrick, secondbrick], extra, times)
        else:
            # pnPN
            return gen_brick([
                hardbrick, secondbrick, twophase,
                phase2_secondbricks.get(text[1])
            ], extra, times)


# text is the wave member of the signal object
# extra = hscale-1 ( padding )


def parse_wavelane(text, extra):
    res = []
    pos = 1
    tlen = len(text)
    subCycle = False
    if tlen == 0:
        return res;
    next = text[0]

    repeats = 1
    while pos < tlen and (text[pos] == '.' or text[pos] == '|'):
        pos += 1
        repeats += 1

    res = gen_first_wavebrick(next, extra, repeats)

    while pos < tlen:
        top = next
        next = text[pos]
        pos += 1
        if next == '<':  # sub-cycles on
            subCycle = True
            next = text[pos]
            pos += 1

        if next == '>':  # sub-cycles off
            subCycle = False
            next = text[pos]
            pos += 1

        repeats = 1
        while pos < tlen and (text[pos] == '.' or text[pos] == '|'):
            pos += 1
            repeats += 1
        if subCycle:
            res.extend(gen_wavebrick(top + next, 0, repeats - lane.period))
        else:
            res.extend(gen_wavebrick(top + next, extra, repeats))

    # res is array of half brick types, each is item is string
    return res


def render_svghead(out, width, height, bricksused, svgn):
    out.write('  <svg id="svgcontent_' + str(svgn) + '"\n')
    out.write(wavesvg_data.head1)
    out.write('height="' + str(height) + '" width="' + str(width) + '"\n')
    out.write('viewBox="0 0 ' + str(width) + ' ' + str(height) + '">\n')
    out.write(wavesvg_data.head2)
    if len(bricksused) > 0:
        out.write(wavesvg_data.defs_head)
        for br in bricksused:
            out.write(wavesvg_data.use_defs[br])
        out.write(wavesvg_data.defs_tail)


def render_svgtail(out):
    out.write(wavesvg_data.tail)


def render_lanes_head(out, xoffset, yoffset, svgn):
    out.write('    <g id="lanes_' + str(svgn) + '" transform="translate(' +
              str(xoffset) + ', ' + str(yoffset) + ')">\n')


def render_events(out, svgn, events, edges):
    out.write('      <g id="wavearcs_' + str(svgn) + '">\n')
    for edge in edges:
        sp_edge = edge.split(None, 1)
        log.info("Edge " + str(edge) + " splits " + str(sp_edge))
        ev_from = events.get(sp_edge[0][0])
        ev_to = events.get(sp_edge[0][-1])
        shape = sp_edge[0][1:-1]
        if (len(sp_edge) > 1):
            label = sp_edge[1]
        else:
            label = ''

        if ev_from == None or ev_to == None or len(shape) < 1:
            log.warn("Could not find events for " + sp_edge[0])
            continue

        dx = ev_to[0] - ev_from[0]
        dy = ev_to[1] - ev_from[1]
        # lx,ly is the center of the label, it may be adjusted
        lx = (ev_to[0] + ev_from[0]) // 2
        ly = (ev_to[1] + ev_from[1]) // 2

        if shape[0] == '<' and shape[-1] == '>':
            path_s = 'marker-end:url(#arrowhead);' \
                     'marker-start:url(#arrowtail);stroke:#0041c4;' \
                     'stroke-width:1;fill:none'
            shape = shape[1:-1]
        elif shape[-1] == '>':
            path_s = 'marker-end:url(#arrowhead);stroke:#0041c4;' \
                     'stroke-width:1;fill:none'
            shape = shape[:-1]
        elif shape[0] == '<':
            path_s = 'marker-start:url(#arrowtail);stroke:#0041c4;' \
                     'stroke-width:1;fill:none'
            shape = shape[1:]
        else:
            path_s = 'fill:none;stroke:#00F;stroke-width:1'

        # SVG uses the case to indicate abs or relative
        path_type = 'M'
        # always start at the from point
        path_d = ' ' + str(ev_from)[1:-1]

        if shape == '~':
            path_d += (' c ' + str(0.7 * dx) + ', 0 ' + str(0.3 * dx) + ', ' +
                       str(dy) + ' ' + str(dx) + ', ' + str(dy))
        elif shape == '-~':
            path_d += (' c ' + str(0.7 * dx) + ', 0 ' + str(dx) + ', ' +
                       str(dy) + ' ' + str(dx) + ', ' + str(dy))
            lx = ev_from[0] + dx * 0.75
        elif shape == '~-':
            path_d += (' c 0, 0 ' + str(0.3 * dx) + ', ' + str(dy) + ' ' +
                       str(dx) + ', ' + str(dy))
            lx = ev_from[0] + dx * 0.25
        elif shape == '-|':
            path_d += ' ' + str(dx) + ',0 0,' + str(dy)
            path_type = 'm'
            lx = ev_to[0]
        elif shape == '|-':
            path_d += ' 0,' + str(dy) + ' ' + str(dx) + ',0'
            path_type = 'm'
            lx = ev_from[0]
        elif shape == '-|-':
            path_d += (' ' + str(dx / 2) + ',0 0,' + str(dy) + ' ' + str(
                dx / 2) + ',0')
            path_type = 'm'
        else:  # catch - here (and anything else)
            path_d += ' ' + str(ev_to)[1:-1]

        out.write('      <path id="gmark_' + sp_edge[0][0] + '_' +
                  sp_edge[0][-1] + '" d="' + path_type + path_d + '" style="' +
                  path_s + '"></path>\n')
        if len(label) != 0:
            out.write('        <rect height="9" '
                      'style="fill: rgb(255, 255, 255);" '
                      'width="' + str(5 * len(label)) + '" '
                      'x="' + str(lx - 2.5 * len(label)) + '" '
                      'y="' + str(ly - 8) + '"></rect>\n')
            out.write('      <text style="font-size: 10px;" '
                      'text-anchor="middle" xml:space="preserve" '
                      'x="' + str(lx) + '" y="' + str(ly) + '">'
                      '<tspan>' + label + '</tspan></text>\n')

    # Do events last so they are on top
    for e in events:
        log.info("Event " + e)
        if e.islower():
            (evx, evy) = events[e]
            # rectangles are taller than in js because it looks better to me
            out.write('        <rect y="' + str(evy - 8) + '" height="12" '
                      'x="' + str(evx - 3) + '" width="6" '
                      'style="fill: rgb(255, 255, 255);"></rect>\n')
            out.write('        <text style="font-size: 8px;" '
                      'x="' + str(evx) + '" y="' + str(evy) + '" '
                      'text-anchor="middle">' + e + '</text>\n')
    out.write('      </g>\n')


def render_wavelanes(out, xscale, yscale, lanes, svgn, events):
    lnum = 0
    x_edgeoff = 6
    for lane in lanes:
        phase = lane[5]

        out.write('      <g id="wavelane_' + str(svgn) + '_' + str(lnum) + '"'
                  ' transform="translate(0,' + str(lnum * yscale + 5) +
                  ')">\n')
        if len(lane[0]) != 0:
            out.write('        <text x="-15" y="15" class="info" '
                      'text-anchor="end" xml:space="preserve">'
                      '<tspan>' + lane[0] + '</tspan></text>\n')
        out.write('        <g id="wavelane_draw_' + str(svgn) + '_' +
                  str(lnum) + '" '
                  'transform="translate(0,0)">\n')
        if phase < 0:
            bnum = abs(phase)
            lstart = 0
        else:
            bnum = 0
            lstart = phase

        for x in lane[1][lstart:]:
            out.write('          <use xlink:href="#' + x + '" '
                      'transform="translate(' + str(bnum * xscale) +
                      ')"></use>\n')
            bnum += 1
        dpos = 0
        dend = len(lane[3])
        period = lane[4]
        if phase < 0:
            i = 0
        else:
            # start point ensures bnum below is never less than -1
            i = phase // 2

        if dend > 0 and lane[3][-1] == '!cdata!':
            lane[3].pop()
            dend -= 1;
            labelif = '01=2345ud'
        else:
            labelif = '=2345'

        scan_max = max(len(lane[2]), len(lane[6]))
        while (i < scan_max):
            bnum = i * 2 - phase

            if (i < len(lane[2])):
                x = lane[2][i]
                if dpos < dend and x in labelif:
                    nslot = 1
                    while (i + nslot) < len(
                            lane[2]) and lane[2][i + nslot] == '.':
                        nslot += 1
                    xcenter = period * xscale * nslot + bnum * period * xscale
                    # the center needs to be offset by the width of the
                    # edge because that lives in the first brick
                    xcenter += x_edgeoff
                    out.write('        <text x="' + str(xcenter))
                    out.write('" y="' + str(yscale / 2) + '" '
                              'text-anchor="middle" xml:space="preserve">')
                    tspan_or_text(out, lane[3][dpos], True)
                    out.write('</text>')
                    dpos = dpos + 1
                if x == '|':
                    # render a gap (this diverges from how the js does it
                    # where it is in a different g
                    out.write('        <use xlink:href="#gap" transform="'
                              'translate(' +
                              str(period * (bnum * xscale + xscale)) + ')"'
                              '></use>\n')

            if i < len(lane[6]):
                ev = lane[6][i]
                if ev != '.':
                    events[ev] = (period * bnum * xscale + x_edgeoff,
                                  lnum * yscale + 2 + yscale // 2)
            i += 1

        out.write('        </g>\n      </g>\n')
        lnum += 1


def render_marks(out, nbricks, xscale, ylen, svgn):
    out.write('      <g id="gmarks_' + str(svgn) + '">\n')
    mnum = 0
    for i in range(nbricks // 2):
        out.write('        <path id="gmark_' + str(svgn) + '_' + str(mnum) +
                  '" '
                  'd="m ' + str(i * 2 * xscale) + ',0 0,' + str(ylen) + '" '
                  'style="stroke: rgb(136, 136, 136); '
                  'stroke-width:0.5; stroke-dasharray:1,3"'
                  '></path>\n')
        mnum += 1
    out.write('      </g>\n')


def tspan_or_text(out, text, outerspan):
    if isinstance(text, str):
        if outerspan: out.write('<tspan>')
        out.write(text)
        if (outerspan): out.write('</tspan>')
    else:
        if text[0] != 'tspan':
            log.warn('Expecting tspan, got ' + str(text[0]))
            return
        if len(text) == 3 and isinstance(text[1], dict):
            out.write('<tspan ')
            for x in text[1]:
                out.write(x + '="' + text[1][x] + '" ')
            out.write('>')
            tspan_or_text(out, text[2], False)
        else:
            out.write('<tspan>')
            for x in text[1:]:
                tspan_or_text(out, x, False)
        out.write('</tspan>')


def render_caption(out, text, nbricks, xscale, yoffset):
    out.write('        <text x="' + str(nbricks * xscale // 2) + '" '
              'y="' + str(yoffset) + '" '
              ' text-anchor="middle" fill="#000" xml:space="preserve">')
    tspan_or_text(out, text, True)
    out.write('</text>\n')


def render_ticktock(out, info, xoff, xsep, yoff, num):
    # info could be a number/string representing the lowest tick number
    # or a string containing a list of space separated labels
    # or a list containing separate strings or a single string

    if isinstance(info, int) or (isinstance(info, str) and info.isdecimal()):
        base = int(info)
        for i in range(num):
            out.write('<text x="' + str(xoff + i * xsep) + '" y="' +
                      str(yoff) + '" '
                      'text-anchor="middle" class="muted" xml:space="preserve"'
                      '>' + str(i + base) + '</text>\n')
    else:
        if isinstance(info, list):
            if len(info) == 1:
                labels = info[0].split()
            else:
                labels = info
        else:
            labels = info.split()
        if num > len(labels):
            num = len(labels)
        for i in range(num):
            out.write('<text x="' + str(xoff + i * xsep) + '" y="' +
                      str(yoff) + '" '
                      'text-anchor="middle" class="muted" xml:space="preserve"'
                      '>' + labels[i] + '</text>\n')


def render_lanes_tail(out):
    out.write('    </g>\n')


# group array is [0=Name, 1=startlane, 2=endlane+1, 3=depth]
def render_groups(out, groups, yhead, yoff, snum):
    gdepth = 0
    if len(groups) == 0:
        return

    for gr in groups:
        if gr[3] > gdepth:
            gdepth = gr[3]
    xgoff = 80 - gdepth * 25

    out.write('    <g id="groups_' + str(snum) + '">\n')

    gnum = 0
    for gr in groups:
        ymin = yhead + gr[1] * yoff
        ylen = (gr[2] - gr[1]) * yoff

        out.write('      <path id="group_' + str(snum) + '_' + str(gnum) +
                  '" ')
        out.write('d="m ' + str(xgoff + 25 * gr[3]) + ',' + str(ymin + 3.5) +
                  ' c -3,0 -5,2 -5,5 l 0,' + str(ylen - 16) + ' c 0,3 2,5 5,5"'
                  'style="stroke: rgb(0, 65, 196); stroke-width: 1; '
                  'fill: none;"></path>\n')
        if len(gr[0]) > 0:
            out.write('      <g transform="translate(' +
                      str(xgoff - 10 + 25 * gr[3]) + ',' +
                      str(ymin + ylen // 2) + ')">\n')
            out.write('        <g transform="rotate(270)">\n')
            out.write('          <text text-anchor="middle" class="info" '
                      'xml:space="preserve"><tspan>' + gr[0] +
                      '</tspan></text>\n        </g>\n      </g>')
        gnum += 1
    out.write('    </g>\n')


def parse_wave(x, hscale, lanes, groups, gdepth, bricksused):
    sname = ""
    wave = ''
    node = ''
    labels = []
    bricks = []
    extra = hscale - 1
    phase = 0
    xmax = 0
    global prevdefs

    if isinstance(x, list):
        gname = x[0]
        startlane = len(lanes)
        for y in x[1:]:
            ymax = parse_wave(y, hscale, lanes, groups, gdepth + 1, bricksused)
            if ymax > xmax:
                xmax = ymax
        groups.append([gname, startlane, len(lanes), gdepth])
        return xmax

    if 'name' in x:
        sname = x['name']

    # period must be before wave because it changes extra
    if 'period' in x:
        fp = float(x['period'])
        if fp < 0 or fp * 2 != int(fp * 2):
            log.error("Period must be integer or 0.5")
        extra = hscale * fp - 1
    if 'phase' in x:
        phase = int(x['phase'] * 2)
    if 'wave' in x:
        wave = x['wave']
        bricks = parse_wavelane(wave, extra)
        for br in bricks:
            if not br in bricksused and not br in prevdefs:
                bricksused.append(br)
        if 'data' in x:
            labels = x['data']
            if isinstance(labels, str):
                labels = labels.split()
        if 'cdata' in x:
            labels = x['cdata']
            if isinstance(labels, str):
                labels = labels.split()
            labels.append('!cdata!')

    if 'node' in x:
        node = x['node']

    lanes.append([sname, bricks, wave, labels, extra + 1, phase, node])
    return len(bricks)


# obj is hjson parsed object with wavejson
# svg_num is a number that makes this svg unique. First one must be 0


def convert(obj, svg_num):
    xs = 20  # x scale = width of cycle
    ys = 20  # y scale = height of wave
    yo = int(ys * 1.5)  # y offest between lines of waves
    xg = 150  # xoffset of waves (space for names and groups)
    yh0 = 0  # height allocated for header tick/tock labels
    yh1 = 0  # height allocated for header string
    headtext = ''  # header string
    headticktock = 0  # does header have tick=1/tock=2
    yf0 = 0  # height allocated for footer tick/tock labels
    yf1 = 0  # height allocated for footer string
    foottext = ''  # footer string
    footticktock = 0  # does footer have tick=1/tock=2
    global prevdefs  # holds bricks previously defined
    events = {}

    if svg_num == 0:
        bricksused = ['gap']
        prevdefs = []
    else:
        bricksused = []

    # section was parseConfig in js
    if 'config' in obj and 'hscale' in obj['config']:
        hscale = int(obj['config']['hscale'])
        log.info("Set hscale to " + str(hscale))
    else:
        hscale = 1

    if 'head' in obj:
        head = obj['head']
        if 'tick' in head:
            yh0 = 20
            headtt = head['tick']
            headticktock = 1
        elif 'tock' in head:
            yh0 = 20
            headtt = head['tock']
            headticktock = 2

        if 'text' in head:
            yh1 = 46
            headtext = head['text']

    if 'foot' in obj:
        foot = obj['foot']
        if 'tick' in foot:
            yf0 = 20
            foottt = foot['tick']
            footticktock = 1
        elif 'tock' in foot:
            yf0 = 20
            foottt = foot['tock']
            footticktock = 2

        if 'text' in foot:
            yf1 = 46
            foottext = foot['text']

    if 'edge' in obj:
        if 'arrows' not in prevdefs:
            bricksused.append('arrows')
        edges = obj['edge']
        log.info("Got edge: " + str(edges))
    else:
        edges = []

    # build the signal bricks array

    lanes = []
    groups = []
    xmax = 0
    if 'signal' in obj:
        for x in obj['signal']:
            xlen = parse_wave(x, hscale, lanes, groups, 0, bricksused)
            if xlen > xmax:
                xmax = xlen

    log.info("Got " + str(len(lanes)) + " lanes. xmax is " + str(xmax))
    log.info(str(lanes))

    outbuf = io.StringIO()

    height = len(lanes) * yo + yh0 + yh1 + yf0 + yf1
    width = xg + xmax * xs + xs
    wheight = len(lanes) * yo

    render_svghead(outbuf, width, height, bricksused, svg_num)
    render_lanes_head(outbuf, xg, yh0 + yh1, svg_num)
    render_marks(outbuf, xmax, xs, wheight, svg_num)
    if yh1 != 0:
        render_caption(outbuf, headtext, xmax, xs, -33 if yh0 != 0 else -13)

    if yf1 != 0:
        render_caption(outbuf, foottext, xmax, xs,
                       wheight + (45 if yf0 != 0 else 25))

    if headticktock == 1:
        render_ticktock(outbuf, headtt, 0, 2 * xs, -5, xmax // 2)
    if headticktock == 2:
        render_ticktock(outbuf, headtt, xs, 2 * xs, -5, xmax // 2)

    if footticktock == 1:
        render_ticktock(outbuf, foottt, 0, 2 * xs, wheight + 15, xmax // 2)
    if footticktock == 2:
        render_ticktock(outbuf, foottt, xs, 2 * xs, wheight + 15, xmax // 2)

    render_wavelanes(outbuf, xs, yo, lanes, svg_num, events)
    if (len(events) > 0):
        render_events(outbuf, svg_num, events, edges)
    render_lanes_tail(outbuf)
    render_groups(outbuf, groups, yh0 + yh1, yo, svg_num)
    render_svgtail(outbuf)
    prevdefs.extend(bricksused)

    generated = outbuf.getvalue()
    outbuf.close()
    return generated