import { LOG_NET } from './const.js'
import { h, hex_dump } from './lib.js'
import { dbg_assert, dbg_log } from './log.js'

import { PCI } from './pci.js'
import { BusConnector } from './bus.js'
import { IO } from './io.js'

// http://www.ethernut.de/pdf/8019asds.pdf

// Minimal interface for the CPU fields Ne2k uses.
interface Ne2kCpu {
    io: IO
    devices: {
        pci: PCI
    }
}

const NE2K_LOG_VERBOSE = false
const NE2K_LOG_PACKETS = false

const E8390_CMD = 0x00 /* The command register (for all pages) */

/* Page 0 register offsets. */
const _EN0_CLDALO = 0x01 /* Low byte of current local dma addr RD */
const EN0_STARTPG = 0x01 /* Starting page of ring bfr WR */
const _EN0_CLDAHI = 0x02 /* High byte of current local dma addr RD */
const EN0_STOPPG = 0x02 /* Ending page +1 of ring bfr WR */
const EN0_BOUNDARY = 0x03 /* Boundary page of ring bfr RD WR */
const EN0_TSR = 0x04 /* Transmit status reg RD */
const EN0_TPSR = 0x04 /* Transmit starting page WR */
const _EN0_NCR = 0x05 /* Number of collision reg RD */
const EN0_TCNTLO = 0x05 /* Low byte of tx byte count WR */
const _EN0_FIFO = 0x06 /* FIFO RD */
const EN0_TCNTHI = 0x06 /* High byte of tx byte count WR */
const EN0_ISR = 0x07 /* Interrupt status reg RD WR */
const _EN0_CRDALO = 0x08 /* low byte of current remote dma address RD */
const EN0_RSARLO = 0x08 /* Remote start address reg 0 */
const _EN0_CRDAHI = 0x09 /* high byte, current remote dma address RD */
const EN0_RSARHI = 0x09 /* Remote start address reg 1 */
const EN0_RCNTLO = 0x0a /* Remote byte count reg WR */
const EN0_RCNTHI = 0x0b /* Remote byte count reg WR */
const EN0_RSR = 0x0c /* rx status reg RD */
const EN0_RXCR = 0x0c /* RX configuration reg WR */
const EN0_TXCR = 0x0d /* TX configuration reg WR */
const EN0_COUNTER0 = 0x0d /* Rcv alignment error counter RD */
const EN0_DCFG = 0x0e /* Data configuration reg WR */
const EN0_COUNTER1 = 0x0e /* Rcv CRC error counter RD */
const EN0_IMR = 0x0f /* Interrupt mask reg WR */
const EN0_COUNTER2 = 0x0f /* Rcv missed frame error counter RD */

const NE_DATAPORT = 0x10 /* NatSemi-defined port window offset. */
const NE_RESET = 0x1f /* Issue a read to reset, a write to clear. */

/* Bits in EN0_ISR - Interrupt status register */
const ENISR_RX = 0x01 /* Receiver, no error */
const ENISR_TX = 0x02 /* Transmitter, no error */
const _ENISR_RX_ERR = 0x04 /* Receiver, with error */
const _ENISR_TX_ERR = 0x08 /* Transmitter, with error */
const _ENISR_OVER = 0x10 /* Receiver overwrote the ring */
const _ENISR_COUNTERS = 0x20 /* Counters need emptying */
const ENISR_RDC = 0x40 /* remote dma complete */
const ENISR_RESET = 0x80 /* Reset completed */
const _ENISR_ALL = 0x3f /* Interrupts we will enable */

const ENRSR_RXOK = 0x01 /* Received a good packet */

const START_PAGE = 0x40
const START_RX_PAGE = 0x40 + 12
const STOP_PAGE = 0x80

// Search and replace MAC addresses in ethernet, arp and dhcp packets.
// Used after restoring an OS from memory dump, so that multiple instances of
// that OS can run at the same time with different external MAC addresses.
// Crude but seems to work.
function translate_mac_address(
    packet: Uint8Array,
    search_mac: Uint8Array,
    replacement_mac: Uint8Array,
): void {
    if (
        packet[0] === search_mac[0] &&
        packet[1] === search_mac[1] &&
        packet[2] === search_mac[2] &&
        packet[3] === search_mac[3] &&
        packet[4] === search_mac[4] &&
        packet[5] === search_mac[5]
    ) {
        dbg_log('Replace mac in eth destination field', LOG_NET)

        packet[0] = replacement_mac[0]
        packet[1] = replacement_mac[1]
        packet[2] = replacement_mac[2]
        packet[3] = replacement_mac[3]
        packet[4] = replacement_mac[4]
        packet[5] = replacement_mac[5]
    }

    if (
        packet[6 + 0] === search_mac[0] &&
        packet[6 + 1] === search_mac[1] &&
        packet[6 + 2] === search_mac[2] &&
        packet[6 + 3] === search_mac[3] &&
        packet[6 + 4] === search_mac[4] &&
        packet[6 + 5] === search_mac[5]
    ) {
        dbg_log('Replace mac in eth source field', LOG_NET)

        packet[6 + 0] = replacement_mac[0]
        packet[6 + 1] = replacement_mac[1]
        packet[6 + 2] = replacement_mac[2]
        packet[6 + 3] = replacement_mac[3]
        packet[6 + 4] = replacement_mac[4]
        packet[6 + 5] = replacement_mac[5]
    }

    const ethertype = (packet[12] << 8) | packet[13]

    if (ethertype === 0x0800) {
        // ipv4
        const ipv4_packet = packet.subarray(14)
        const ipv4_version = ipv4_packet[0] >> 4

        if (ipv4_version !== 4) {
            dbg_log(
                'Expected ipv4.version==4 but got: ' + ipv4_version,
                LOG_NET,
            )
            return
        }

        const ipv4_ihl = ipv4_packet[0] & 0xf
        dbg_assert(ipv4_ihl === 5, 'TODO: ihl!=5')

        const ipv4_proto = ipv4_packet[9]
        if (ipv4_proto === 0x11) {
            // udp
            const udp_packet = ipv4_packet.subarray(5 * 4)
            const source_port = (udp_packet[0] << 8) | udp_packet[1]
            const destination_port = (udp_packet[2] << 8) | udp_packet[3]
            const checksum = (udp_packet[6] << 8) | udp_packet[7]

            dbg_log(
                'udp srcport=' +
                    source_port +
                    ' dstport=' +
                    destination_port +
                    ' checksum=' +
                    h(checksum, 4),
                LOG_NET,
            )

            if (source_port === 67 || destination_port === 67) {
                // dhcp
                const dhcp_packet = udp_packet.subarray(8)
                const dhcp_magic =
                    (dhcp_packet[0xec] << 24) |
                    (dhcp_packet[0xed] << 16) |
                    (dhcp_packet[0xee] << 8) |
                    dhcp_packet[0xef]

                if (dhcp_magic !== 0x63825363) {
                    dbg_log(
                        "dhcp packet didn't match magic: " + h(dhcp_magic, 8),
                    )
                    return
                }

                if (
                    dhcp_packet[28 + 0] === search_mac[0] &&
                    dhcp_packet[28 + 1] === search_mac[1] &&
                    dhcp_packet[28 + 2] === search_mac[2] &&
                    dhcp_packet[28 + 3] === search_mac[3] &&
                    dhcp_packet[28 + 4] === search_mac[4] &&
                    dhcp_packet[28 + 5] === search_mac[5]
                ) {
                    dbg_log('Replace mac in dhcp.chaddr', LOG_NET)

                    dhcp_packet[28 + 0] = replacement_mac[0]
                    dhcp_packet[28 + 1] = replacement_mac[1]
                    dhcp_packet[28 + 2] = replacement_mac[2]
                    dhcp_packet[28 + 3] = replacement_mac[3]
                    dhcp_packet[28 + 4] = replacement_mac[4]
                    dhcp_packet[28 + 5] = replacement_mac[5]

                    udp_packet[6] = udp_packet[7] = 0 // zero udp checksum
                }

                let offset = 0xf0
                while (offset < dhcp_packet.length) {
                    const dhcp_option_type = dhcp_packet[offset++]

                    if (dhcp_option_type === 0xff) {
                        break
                    }

                    const length = dhcp_packet[offset++]

                    if (
                        dhcp_option_type === 0x3d && // client identifier
                        dhcp_packet[offset + 0] === 0x01 && // ethernet
                        dhcp_packet[offset + 1] === search_mac[0] &&
                        dhcp_packet[offset + 2] === search_mac[1] &&
                        dhcp_packet[offset + 3] === search_mac[2] &&
                        dhcp_packet[offset + 4] === search_mac[3] &&
                        dhcp_packet[offset + 5] === search_mac[4] &&
                        dhcp_packet[offset + 6] === search_mac[5]
                    ) {
                        dbg_log('Replace mac in dhcp.clientidentifier', LOG_NET)

                        dhcp_packet[offset + 1] = replacement_mac[0]
                        dhcp_packet[offset + 2] = replacement_mac[1]
                        dhcp_packet[offset + 3] = replacement_mac[2]
                        dhcp_packet[offset + 4] = replacement_mac[3]
                        dhcp_packet[offset + 5] = replacement_mac[4]
                        dhcp_packet[offset + 6] = replacement_mac[5]

                        udp_packet[6] = udp_packet[7] = 0 // zero udp checksum
                    }

                    offset += length
                }
            }
        } else {
            // tcp, ...
        }
    } else if (ethertype === 0x0806) {
        // arp
        const arp_packet = packet.subarray(14)
        dbg_log(
            'arp oper=' +
                arp_packet[7] +
                ' ' +
                format_mac(arp_packet.subarray(8, 8 + 6)) +
                ' ' +
                format_mac(arp_packet.subarray(18, 18 + 6)),
            LOG_NET,
        )

        if (
            arp_packet[8 + 0] === search_mac[0] &&
            arp_packet[8 + 1] === search_mac[1] &&
            arp_packet[8 + 2] === search_mac[2] &&
            arp_packet[8 + 3] === search_mac[3] &&
            arp_packet[8 + 4] === search_mac[4] &&
            arp_packet[8 + 5] === search_mac[5]
        ) {
            dbg_log('Replace mac in arp.sha', LOG_NET)

            arp_packet[8 + 0] = replacement_mac[0]
            arp_packet[8 + 1] = replacement_mac[1]
            arp_packet[8 + 2] = replacement_mac[2]
            arp_packet[8 + 3] = replacement_mac[3]
            arp_packet[8 + 4] = replacement_mac[4]
            arp_packet[8 + 5] = replacement_mac[5]
        }
    } else {
        // TODO: ipv6, ...
    }
}

export function format_mac(mac: Uint8Array): string {
    return [
        mac[0].toString(16).padStart(2, '0'),
        mac[1].toString(16).padStart(2, '0'),
        mac[2].toString(16).padStart(2, '0'),
        mac[3].toString(16).padStart(2, '0'),
        mac[4].toString(16).padStart(2, '0'),
        mac[5].toString(16).padStart(2, '0'),
    ].join(':')
}

function dump_packet(packet: Uint8Array, prefix: string): void {
    const ethertype = (packet[12] << 8) | (packet[13] << 0)
    if (ethertype === 0x0800) {
        const ipv4_packet = packet.subarray(14)
        const ipv4_len = (ipv4_packet[2] << 8) | ipv4_packet[3]
        const ipv4_proto = ipv4_packet[9]
        if (ipv4_proto === 0x11) {
            const udp_packet = ipv4_packet.subarray(5 * 4)
            const source_port = (udp_packet[0] << 8) | udp_packet[1]
            const destination_port = (udp_packet[2] << 8) | udp_packet[3]
            const checksum = (udp_packet[6] << 8) | udp_packet[7]

            if (source_port === 67 || destination_port === 67) {
                const dhcp_packet = udp_packet.subarray(8)
                const dhcp_chaddr = dhcp_packet.subarray(28, 28 + 6)
                dbg_log(
                    prefix +
                        ' len=' +
                        packet.length +
                        ' ethertype=' +
                        h(ethertype) +
                        ' ipv4.len=' +
                        ipv4_len +
                        ' ipv4.proto=' +
                        h(packet[14 + 9]) +
                        ' udp.srcport=' +
                        source_port +
                        ' udp.dstport=' +
                        destination_port +
                        ' udp.chksum=' +
                        h(checksum, 4) +
                        ' dhcp.chaddr=' +
                        format_mac(dhcp_chaddr),
                )
            } else {
                dbg_log(
                    prefix +
                        ' len=' +
                        packet.length +
                        ' ethertype=' +
                        h(ethertype) +
                        ' ipv4.len=' +
                        ipv4_len +
                        ' ipv4.proto=' +
                        h(packet[14 + 9]) +
                        ' udp.srcport=' +
                        source_port +
                        ' udp.dstport=' +
                        destination_port +
                        ' udp.chksum=' +
                        h(checksum, 4),
                )
            }
        } else if (ipv4_proto === 0x01) {
            // icmp, intentionally empty
        } else {
            dbg_log(
                prefix +
                    ' len=' +
                    packet.length +
                    ' ethertype=' +
                    h(ethertype) +
                    ' ipv4.len=' +
                    ipv4_len +
                    ' ipv4.proto=' +
                    h(packet[14 + 9]),
            )
        }
    } else {
        const _arp_packet = packet.subarray(14)
        dbg_log(
            prefix +
                ' len=' +
                packet.length +
                ' ethertype=' +
                h(ethertype) +
                ' arp',
        )
    }
    dbg_log(hex_dump(packet))
}

export class Ne2k {
    name: string
    cpu: Ne2kCpu
    pci: PCI
    id: number
    preserve_mac_from_state_image: boolean
    mac_address_translation: boolean
    bus: BusConnector
    port: number

    pci_space: number[]
    pci_id: number
    pci_bars: { size: number }[]

    isr: number
    imr: number
    cr: number
    dcfg: number
    rcnt: number
    tcnt: number
    tpsr: number
    memory: Uint8Array
    rxcr: number
    txcr: number
    tsr: number
    mac: Uint8Array
    mar: Uint8Array
    mac_address_in_state: Uint8Array | null
    rsar: number
    pstart: number
    pstop: number
    curpg: number
    boundary: number

    constructor(
        cpu: Ne2kCpu,
        bus: BusConnector,
        preserve_mac_from_state_image: boolean,
        mac_address_translation: boolean,
        id?: number,
    ) {
        this.cpu = cpu
        this.pci = cpu.devices.pci
        this.id = id || 0
        this.preserve_mac_from_state_image = preserve_mac_from_state_image
        this.mac_address_translation = mac_address_translation
        this.bus = bus
        this.bus.register(
            'net' + this.id + '-receive',
            function (this: Ne2k, data: Uint8Array) {
                this.receive(data)
            },
            this,
        )

        this.port = 0x300 + 0x100 * this.id

        this.name = 'ne2k'

        const use_pci = true

        if (use_pci) {
            this.pci_space = [
                0xec,
                0x10,
                0x29,
                0x80,
                0x03,
                0x01,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0x02,
                0x00,
                0x00,
                0x00,
                0x00,
                (this.port & 0xff) | 1,
                this.port >> 8,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0xf4,
                0x1a,
                0x00,
                0x11,
                0x00,
                0x00,
                0xb8,
                0xfe,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0x00,
                0x01,
                0x00,
                0x00,
            ]
            this.pci_id = (this.id === 0 ? 0x05 : 0x07 + this.id) << 3
            this.pci_bars = [
                {
                    size: 32,
                },
            ]
        } else {
            this.pci_space = []
            this.pci_id = 0
            this.pci_bars = []
        }

        this.isr = 0
        this.imr = 0 // interrupt mask register

        this.cr = 1

        this.dcfg = 0

        this.rcnt = 0

        this.tcnt = 0
        this.tpsr = 0
        this.memory = new Uint8Array(256 * 0x80)

        this.rxcr = 0
        this.txcr = 0
        this.tsr = 1

        // mac address
        this.mac = new Uint8Array([
            0x00,
            0x22,
            0x15,
            (Math.random() * 255) | 0,
            (Math.random() * 255) | 0,
            (Math.random() * 255) | 0,
        ])

        this.bus.send('net' + this.id + '-mac', format_mac(this.mac))

        // multicast addresses
        this.mar = Uint8Array.of(0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff)

        // Used for mac address translation
        // The mac the OS thinks it has
        this.mac_address_in_state = null

        for (let i = 0; i < 6; i++) {
            this.memory[i << 1] = this.memory[(i << 1) | 1] = this.mac[i]
        }

        // the PROM signature of 0x57, 0x57 is also doubled
        // resulting in setting the 4 bytes at the end, 28, 29, 30 and 31 to 0x57
        this.memory[14 << 1] = this.memory[(14 << 1) | 1] = 0x57
        this.memory[15 << 1] = this.memory[(15 << 1) | 1] = 0x57

        dbg_log('Mac: ' + format_mac(this.mac), LOG_NET)

        this.rsar = 0

        this.pstart = START_PAGE
        this.pstop = STOP_PAGE

        this.curpg = START_RX_PAGE
        this.boundary = START_RX_PAGE

        const io = cpu.io

        io.register_read(
            this.port | E8390_CMD,
            this,
            function (this: Ne2k): number {
                dbg_log('Read cmd', LOG_NET)
                return this.cr
            },
            function (this: Ne2k): number {
                dbg_log('Read16 cmd', LOG_NET)
                return this.cr
            },
        )

        io.register_write(
            this.port | E8390_CMD,
            this,
            function (this: Ne2k, data_byte: number): void {
                this.cr = data_byte
                dbg_log(
                    'Write command: ' +
                        h(data_byte, 2) +
                        ' newpg=' +
                        (this.cr >> 6) +
                        ' txcr=' +
                        h(this.txcr, 2),
                    LOG_NET,
                )

                if (this.cr & 1) {
                    return
                }

                if (data_byte & 0x18 && this.rcnt === 0) {
                    this.do_interrupt(ENISR_RDC)
                }

                if (data_byte & 4) {
                    const start = this.tpsr << 8
                    let data: Uint8Array = this.memory.subarray(
                        start,
                        start + this.tcnt,
                    )

                    if (NE2K_LOG_PACKETS) {
                        dump_packet(data, 'send')
                    }

                    if (this.mac_address_in_state) {
                        data = new Uint8Array(data) // make a copy
                        translate_mac_address(
                            data,
                            this.mac_address_in_state,
                            this.mac,
                        )
                    }

                    this.bus.send('net' + this.id + '-send', data)
                    this.bus.send('eth-transmit-end', [data.length])
                    this.cr &= ~4
                    this.do_interrupt(ENISR_TX)

                    dbg_log(
                        'Command: Transfer. length=' + h(data.byteLength),
                        LOG_NET,
                    )
                }
            },
        )

        io.register_read(
            this.port | EN0_COUNTER0,
            this,
            function (this: Ne2k): number {
                const pg = this.get_page()
                if (pg === 1) {
                    dbg_log('Read mar5', LOG_NET)
                    return this.mar[5]
                } else {
                    dbg_log('Read counter0 pg=' + pg, LOG_NET)
                    return 0
                }
            },
        )

        io.register_read(
            this.port | EN0_COUNTER1,
            this,
            function (this: Ne2k): number {
                const pg = this.get_page()
                if (pg === 1) {
                    dbg_log('Read mar6', LOG_NET)
                    return this.mar[6]
                } else {
                    dbg_log('Read8 counter1 pg=' + pg, LOG_NET)
                    return 0
                }
            },
            function (this: Ne2k): number {
                dbg_log('Read16 counter1 pg=' + this.get_page(), LOG_NET)
                // openbsd
                return 0
            },
        )

        io.register_read(
            this.port | EN0_COUNTER2,
            this,
            function (this: Ne2k): number {
                const pg = this.get_page()
                if (pg === 1) {
                    dbg_log('Read mar7', LOG_NET)
                    return this.mar[7]
                } else {
                    dbg_log('Read counter2 pg=' + pg, LOG_NET)
                    return 0
                }
            },
        )

        io.register_read(
            this.port | NE_RESET,
            this,
            function (this: Ne2k): number {
                dbg_log('Read reset', LOG_NET)
                this.do_interrupt(ENISR_RESET)
                return 0
            },
        )

        io.register_write(
            this.port | NE_RESET,
            this,
            function (this: Ne2k, data_byte: number): void {
                dbg_log('Write reset: ' + h(data_byte, 2), LOG_NET)
                //this.isr &= ~ENISR_RESET;
            },
        )

        io.register_read(
            this.port | EN0_STARTPG,
            this,
            function (this: Ne2k): number {
                const pg = this.get_page()
                if (pg === 0) {
                    return this.pstart
                } else if (pg === 1) {
                    dbg_log('Read pg1/01 (mac[0])', LOG_NET)
                    return this.mac[0]
                } else if (pg === 2) {
                    return this.pstart
                } else {
                    dbg_log('Read pg' + pg + '/01')
                    dbg_assert(false)
                    return 0
                }
            },
        )

        io.register_write(
            this.port | EN0_STARTPG,
            this,
            function (this: Ne2k, data_byte: number): void {
                const pg = this.get_page()
                if (pg === 0) {
                    dbg_log('start page: ' + h(data_byte, 2), LOG_NET)
                    this.pstart = data_byte
                } else if (pg === 1) {
                    dbg_log('mac[0] = ' + h(data_byte), LOG_NET)
                    this.mac[0] = data_byte
                } else if (pg === 3) {
                    dbg_log(
                        'Unimplemented: Write pg3/01 (9346CR): ' + h(data_byte),
                        LOG_NET,
                    )
                } else {
                    dbg_log('Write pg' + pg + '/01: ' + h(data_byte), LOG_NET)
                    dbg_assert(false)
                }
            },
        )

        io.register_read(
            this.port | EN0_STOPPG,
            this,
            function (this: Ne2k): number {
                const pg = this.get_page()
                if (pg === 0) {
                    return this.pstop
                } else if (pg === 1) {
                    dbg_log('Read pg1/02 (mac[1])', LOG_NET)
                    return this.mac[1]
                } else if (pg === 2) {
                    return this.pstop
                } else {
                    dbg_log('Read pg' + pg + '/02', LOG_NET)
                    dbg_assert(false)
                    return 0
                }
            },
        )

        io.register_write(
            this.port | EN0_STOPPG,
            this,
            function (this: Ne2k, data_byte: number): void {
                const pg = this.get_page()
                if (pg === 0) {
                    dbg_log('stop page: ' + h(data_byte, 2), LOG_NET)
                    if (data_byte > this.memory.length >> 8) {
                        data_byte = this.memory.length >> 8
                        dbg_log(
                            'XXX: Adjusting stop page to ' + h(data_byte),
                            LOG_NET,
                        )
                    }
                    this.pstop = data_byte
                } else if (pg === 1) {
                    dbg_log('mac[1] = ' + h(data_byte), LOG_NET)
                    this.mac[1] = data_byte
                } else {
                    dbg_log('Write pg' + pg + '/02: ' + h(data_byte), LOG_NET)
                    dbg_assert(false)
                }
            },
        )

        io.register_read(
            this.port | EN0_ISR,
            this,
            function (this: Ne2k): number {
                const pg = this.get_page()
                if (pg === 0) {
                    dbg_log('Read isr: ' + h(this.isr, 2), LOG_NET)
                    return this.isr
                } else if (pg === 1) {
                    dbg_log('Read curpg: ' + h(this.curpg, 2), LOG_NET)
                    return this.curpg
                } else {
                    dbg_assert(false)
                    return 0
                }
            },
        )

        io.register_write(
            this.port | EN0_ISR,
            this,
            function (this: Ne2k, data_byte: number): void {
                const pg = this.get_page()
                if (pg === 0) {
                    // acknowledge interrupts where bit is set
                    dbg_log('Write isr: ' + h(data_byte, 2), LOG_NET)
                    this.isr &= ~data_byte
                    this.update_irq()
                } else if (pg === 1) {
                    dbg_log('Write curpg: ' + h(data_byte, 2), LOG_NET)
                    this.curpg = data_byte
                } else {
                    dbg_assert(false)
                }
            },
        )

        io.register_write(
            this.port | EN0_TXCR,
            this,
            function (this: Ne2k, data_byte: number): void {
                const pg = this.get_page()
                if (pg === 0) {
                    this.txcr = data_byte
                    dbg_log('Write tx config: ' + h(data_byte, 2), LOG_NET)
                } else {
                    dbg_log(
                        'Unimplemented: Write pg' +
                            pg +
                            '/0d ' +
                            h(data_byte, 2),
                        LOG_NET,
                    )
                }
            },
        )

        io.register_write(
            this.port | EN0_DCFG,
            this,
            function (this: Ne2k, data_byte: number): void {
                const pg = this.get_page()
                if (pg === 0) {
                    dbg_log(
                        'Write data configuration: ' + h(data_byte, 2),
                        LOG_NET,
                    )
                    this.dcfg = data_byte
                } else {
                    dbg_log(
                        'Unimplemented: Write pg' +
                            pg +
                            '/0e ' +
                            h(data_byte, 2),
                        LOG_NET,
                    )
                }
            },
        )

        io.register_read(
            this.port | EN0_RCNTLO,
            this,
            function (this: Ne2k): number {
                const pg = this.get_page()
                if (pg === 0) {
                    dbg_log('Read pg0/0a', LOG_NET)
                    return 0x50
                } else if (pg === 1) {
                    dbg_log('Read mar2', LOG_NET)
                    return this.mar[2]
                } else {
                    dbg_assert(false, 'TODO')
                    return 0
                }
            },
        )

        io.register_write(
            this.port | EN0_RCNTLO,
            this,
            function (this: Ne2k, data_byte: number): void {
                const pg = this.get_page()
                if (pg === 0) {
                    dbg_log(
                        'Write remote byte count low: ' + h(data_byte, 2),
                        LOG_NET,
                    )
                    this.rcnt = (this.rcnt & 0xff00) | (data_byte & 0xff)
                } else {
                    dbg_log(
                        'Unimplemented: Write pg' +
                            pg +
                            '/0a ' +
                            h(data_byte, 2),
                        LOG_NET,
                    )
                }
            },
        )

        io.register_read(
            this.port | EN0_RCNTHI,
            this,
            function (this: Ne2k): number {
                const pg = this.get_page()
                if (pg === 0) {
                    dbg_log('Read pg0/0b', LOG_NET)
                    return 0x43
                } else if (pg === 1) {
                    dbg_log('Read mar3', LOG_NET)
                    return this.mar[3]
                } else {
                    dbg_assert(false, 'TODO')
                    return 0
                }
            },
        )

        io.register_write(
            this.port | EN0_RCNTHI,
            this,
            function (this: Ne2k, data_byte: number): void {
                const pg = this.get_page()
                if (pg === 0) {
                    dbg_log(
                        'Write remote byte count high: ' + h(data_byte, 2),
                        LOG_NET,
                    )
                    this.rcnt = (this.rcnt & 0xff) | ((data_byte << 8) & 0xff00)
                } else {
                    dbg_log(
                        'Unimplemented: Write pg' +
                            pg +
                            '/0b ' +
                            h(data_byte, 2),
                        LOG_NET,
                    )
                }
            },
        )

        io.register_read(
            this.port | EN0_RSARLO,
            this,
            function (this: Ne2k): number {
                const pg = this.get_page()
                if (pg === 0) {
                    dbg_log('Read remote start address low', LOG_NET)
                    return this.rsar & 0xff
                } else if (pg === 1) {
                    dbg_log('Read mar0', LOG_NET)
                    return this.mar[0]
                } else {
                    dbg_log('Unimplemented: Read pg' + pg + '/08', LOG_NET)
                    dbg_assert(false)
                    return 0
                }
            },
        )

        io.register_write(
            this.port | EN0_RSARLO,
            this,
            function (this: Ne2k, data_byte: number): void {
                const pg = this.get_page()
                if (pg === 0) {
                    dbg_log(
                        'Write remote start address low: ' + h(data_byte, 2),
                        LOG_NET,
                    )
                    this.rsar = (this.rsar & 0xff00) | (data_byte & 0xff)
                } else {
                    dbg_log(
                        'Unimplemented: Write pg' +
                            pg +
                            '/08 ' +
                            h(data_byte, 2),
                        LOG_NET,
                    )
                }
            },
        )

        io.register_read(
            this.port | EN0_RSARHI,
            this,
            function (this: Ne2k): number {
                const pg = this.get_page()
                if (pg === 0) {
                    dbg_log('Read remote start address high', LOG_NET)
                    return (this.rsar >> 8) & 0xff
                } else if (pg === 1) {
                    dbg_log('Read mar1', LOG_NET)
                    return this.mar[1]
                } else {
                    dbg_log('Unimplemented: Read pg' + pg + '/09', LOG_NET)
                    dbg_assert(false)
                    return 0
                }
            },
        )

        io.register_write(
            this.port | EN0_RSARHI,
            this,
            function (this: Ne2k, data_byte: number): void {
                const pg = this.get_page()
                if (pg === 0) {
                    dbg_log(
                        'Write remote start address low: ' + h(data_byte, 2),
                        LOG_NET,
                    )
                    this.rsar = (this.rsar & 0xff) | ((data_byte << 8) & 0xff00)
                } else {
                    dbg_log(
                        'Unimplemented: Write pg' +
                            pg +
                            '/09 ' +
                            h(data_byte, 2),
                        LOG_NET,
                    )
                }
            },
        )

        io.register_write(
            this.port | EN0_IMR,
            this,
            function (this: Ne2k, data_byte: number): void {
                const pg = this.get_page()
                if (pg === 0) {
                    dbg_log(
                        'Write interrupt mask register: ' +
                            h(data_byte, 2) +
                            ' isr=' +
                            h(this.isr, 2),
                        LOG_NET,
                    )
                    this.imr = data_byte
                    this.update_irq()
                } else {
                    dbg_log(
                        'Unimplemented: Write pg' +
                            pg +
                            '/0f ' +
                            h(data_byte, 2),
                        LOG_NET,
                    )
                }
            },
        )

        io.register_read(
            this.port | EN0_BOUNDARY,
            this,
            function (this: Ne2k): number {
                const pg = this.get_page()
                if (pg === 0) {
                    dbg_log('Read boundary: ' + h(this.boundary, 2), LOG_NET)
                    return this.boundary
                } else if (pg === 1) {
                    dbg_log('Read pg1/03 (mac[2])', LOG_NET)
                    return this.mac[2]
                } else if (pg === 3) {
                    dbg_log('Unimplemented: Read pg3/03 (CONFIG0)', LOG_NET)
                    return 0
                } else {
                    dbg_log('Read pg' + pg + '/03', LOG_NET)
                    dbg_assert(false)
                    return 0
                }
            },
        )

        io.register_write(
            this.port | EN0_BOUNDARY,
            this,
            function (this: Ne2k, data_byte: number): void {
                const pg = this.get_page()
                if (pg === 0) {
                    dbg_log('Write boundary: ' + h(data_byte, 2), LOG_NET)
                    this.boundary = data_byte
                } else if (pg === 1) {
                    dbg_log('mac[2] = ' + h(data_byte), LOG_NET)
                    this.mac[2] = data_byte
                } else {
                    dbg_log('Write pg' + pg + '/03: ' + h(data_byte), LOG_NET)
                    dbg_assert(false)
                }
            },
        )

        io.register_read(
            this.port | EN0_TSR,
            this,
            function (this: Ne2k): number {
                const pg = this.get_page()
                if (pg === 0) {
                    return this.tsr
                } else if (pg === 1) {
                    dbg_log('Read pg1/04 (mac[3])', LOG_NET)
                    return this.mac[3]
                } else {
                    dbg_log('Read pg' + pg + '/04', LOG_NET)
                    dbg_assert(false)
                    return 0
                }
            },
        )

        io.register_write(
            this.port | EN0_TPSR,
            this,
            function (this: Ne2k, data_byte: number): void {
                const pg = this.get_page()
                if (pg === 0) {
                    dbg_log('Write tpsr: ' + h(data_byte, 2), LOG_NET)
                    this.tpsr = data_byte
                } else if (pg === 1) {
                    dbg_log('mac[3] = ' + h(data_byte), LOG_NET)
                    this.mac[3] = data_byte
                } else {
                    dbg_log('Write pg' + pg + '/04: ' + h(data_byte), LOG_NET)
                    dbg_assert(false)
                }
            },
        )

        io.register_read(
            this.port | EN0_TCNTLO,
            this,
            function (this: Ne2k): number {
                const pg = this.get_page()
                if (pg === 0) {
                    dbg_log(
                        'Unimplemented: Read pg0/05 (NCR: Number of Collisions Register)',
                        LOG_NET,
                    )
                    return 0
                } else if (pg === 1) {
                    dbg_log('Read pg1/05 (mac[4])', LOG_NET)
                    return this.mac[4]
                } else if (pg === 3) {
                    dbg_log('Unimplemented: Read pg3/05 (CONFIG2)', LOG_NET)
                    return 0
                } else {
                    dbg_log('Read pg' + pg + '/05', LOG_NET)
                    dbg_assert(false)
                    return 0
                }
            },
        )

        io.register_write(
            this.port | EN0_TCNTLO,
            this,
            function (this: Ne2k, data_byte: number): void {
                const pg = this.get_page()
                if (pg === 0) {
                    dbg_log('Write tcnt low: ' + h(data_byte, 2), LOG_NET)
                    this.tcnt = (this.tcnt & ~0xff) | data_byte
                } else if (pg === 1) {
                    dbg_log('mac[4] = ' + h(data_byte), LOG_NET)
                    this.mac[4] = data_byte
                } else if (pg === 3) {
                    dbg_log(
                        'Unimplemented: Write pg3/05 (CONFIG2): ' +
                            h(data_byte),
                        LOG_NET,
                    )
                } else {
                    dbg_log('Write pg' + pg + '/05: ' + h(data_byte), LOG_NET)
                    dbg_assert(false)
                }
            },
        )

        io.register_read(
            this.port | EN0_TCNTHI,
            this,
            function (this: Ne2k): number {
                const pg = this.get_page()
                if (pg === 0) {
                    dbg_assert(false, 'TODO')
                    return 0
                } else if (pg === 1) {
                    dbg_log('Read pg1/06 (mac[5])', LOG_NET)
                    return this.mac[5]
                } else if (pg === 3) {
                    dbg_log('Unimplemented: Read pg3/06 (CONFIG3)', LOG_NET)
                    return 0
                } else {
                    dbg_log('Read pg' + pg + '/06', LOG_NET)
                    dbg_assert(false)
                    return 0
                }
            },
        )

        io.register_write(
            this.port | EN0_TCNTHI,
            this,
            function (this: Ne2k, data_byte: number): void {
                const pg = this.get_page()
                if (pg === 0) {
                    dbg_log('Write tcnt high: ' + h(data_byte, 2), LOG_NET)
                    this.tcnt = (this.tcnt & 0xff) | (data_byte << 8)
                } else if (pg === 1) {
                    dbg_log('mac[5] = ' + h(data_byte), LOG_NET)
                    this.mac[5] = data_byte
                } else if (pg === 3) {
                    dbg_log(
                        'Unimplemented: Write pg3/06 (CONFIG3): ' +
                            h(data_byte),
                        LOG_NET,
                    )
                } else {
                    dbg_log('Write pg' + pg + '/06: ' + h(data_byte), LOG_NET)
                    dbg_assert(false)
                }
            },
        )

        io.register_read(
            this.port | EN0_RSR,
            this,
            function (this: Ne2k): number {
                const pg = this.get_page()
                if (pg === 0) {
                    return 1 | (1 << 3) // receive status ok
                } else if (pg === 1) {
                    dbg_log('Read mar4', LOG_NET)
                    return this.mar[4]
                } else {
                    dbg_log('Unimplemented: Read pg' + pg + '/0c', LOG_NET)
                    dbg_assert(false)
                    return 0
                }
            },
        )

        io.register_write(
            this.port | EN0_RXCR,
            this,
            function (this: Ne2k, data_byte: number): void {
                const pg = this.get_page()
                if (pg === 0) {
                    dbg_log(
                        'RX configuration reg write: ' + h(data_byte, 2),
                        LOG_NET,
                    )
                    this.rxcr = data_byte
                } else {
                    dbg_log(
                        'Unimplemented: Write pg' + pg + '/0c: ' + h(data_byte),
                        LOG_NET,
                    )
                }
            },
        )

        io.register_read(
            this.port | NE_DATAPORT | 0,
            this,
            this.data_port_read8,
            this.data_port_read16,
            this.data_port_read32,
        )
        io.register_write(
            this.port | NE_DATAPORT | 0,
            this,
            this.data_port_write16,
            this.data_port_write16,
            this.data_port_write32,
        )

        if (use_pci) {
            cpu.devices.pci.register_device(this)
        }
    }

    get_state(): (number | Uint8Array)[] {
        const state: (number | Uint8Array)[] = []

        state[0] = this.isr
        state[1] = this.imr
        state[2] = this.cr
        state[3] = this.dcfg
        state[4] = this.rcnt
        state[5] = this.tcnt
        state[6] = this.tpsr
        state[7] = this.rsar
        state[8] = this.pstart
        state[9] = this.curpg
        state[10] = this.boundary
        state[11] = this.pstop
        state[12] = this.rxcr
        state[13] = this.txcr
        state[14] = this.tsr
        state[15] = this.mac
        state[16] = this.memory

        return state
    }

    set_state(state: any[]): void {
        this.isr = state[0]
        this.imr = state[1]
        this.cr = state[2]
        this.dcfg = state[3]
        this.rcnt = state[4]
        this.tcnt = state[5]
        this.tpsr = state[6]
        this.rsar = state[7]
        this.pstart = state[8]
        this.curpg = state[9]
        this.boundary = state[10]
        this.pstop = state[11]
        this.rxcr = state[12]
        this.txcr = state[13]
        this.tsr = state[14]

        if (this.preserve_mac_from_state_image) {
            this.mac = state[15]
            this.memory = state[16]
        } else if (this.mac_address_translation) {
            this.mac_address_in_state = state[15]
            this.memory = state[16]

            dbg_log(
                'Using mac address translation' +
                    ' guest_os_mac=' +
                    format_mac(this.mac_address_in_state!) +
                    ' real_mac=' +
                    format_mac(this.mac),
                LOG_NET,
            )
        }
        this.bus.send('net' + this.id + '-mac', format_mac(this.mac))
    }

    do_interrupt(ir_mask: number): void {
        dbg_log('Do interrupt ' + h(ir_mask, 2), LOG_NET)
        this.isr |= ir_mask
        this.update_irq()
    }

    update_irq(): void {
        if (this.imr & this.isr) {
            this.pci.raise_irq(this.pci_id)
        } else {
            this.pci.lower_irq(this.pci_id)
        }
    }

    data_port_write(data_byte: number): void {
        if (NE2K_LOG_VERBOSE) {
            dbg_log(
                'Write data port: data=' +
                    h(data_byte & 0xff, 2) +
                    ' rsar=' +
                    h(this.rsar, 4) +
                    ' rcnt=' +
                    h(this.rcnt, 4),
                LOG_NET,
            )
        }

        if (
            this.rsar <= 0x10 ||
            (this.rsar >= START_PAGE << 8 && this.rsar < STOP_PAGE << 8)
        ) {
            this.memory[this.rsar] = data_byte
        }

        this.rsar++
        this.rcnt--

        if (this.rsar >= this.pstop << 8) {
            this.rsar += (this.pstart - this.pstop) << 8
        }

        if (this.rcnt === 0) {
            this.do_interrupt(ENISR_RDC)
        }
    }

    data_port_write16(data: number): void {
        this.data_port_write(data)

        if (this.dcfg & 1) {
            this.data_port_write(data >> 8)
        }
    }

    data_port_write32(data: number): void {
        this.data_port_write(data)
        this.data_port_write(data >> 8)
        this.data_port_write(data >> 16)
        this.data_port_write(data >> 24)
    }

    data_port_read(): number {
        let data = 0

        if (this.rsar < STOP_PAGE << 8) {
            data = this.memory[this.rsar]
        }

        if (NE2K_LOG_VERBOSE) {
            dbg_log(
                'Read data port: data=' +
                    h(data, 2) +
                    ' rsar=' +
                    h(this.rsar, 4) +
                    ' rcnt=' +
                    h(this.rcnt, 4),
                LOG_NET,
            )
        }

        this.rsar++
        this.rcnt--

        if (this.rsar >= this.pstop << 8) {
            this.rsar += (this.pstart - this.pstop) << 8
        }

        if (this.rcnt === 0) {
            this.do_interrupt(ENISR_RDC)
        }

        return data
    }

    data_port_read8(): number {
        return this.data_port_read16() & 0xff
    }

    data_port_read16(): number {
        if (this.dcfg & 1) {
            return this.data_port_read() | (this.data_port_read() << 8)
        } else {
            return this.data_port_read()
        }
    }

    data_port_read32(): number {
        return (
            this.data_port_read() |
            (this.data_port_read() << 8) |
            (this.data_port_read() << 16) |
            (this.data_port_read() << 24)
        )
    }

    receive(data: Uint8Array): void {
        // called from the adapter when data is received over the network

        if (this.cr & 1) {
            // stop bit set
            return
        }

        if (NE2K_LOG_PACKETS) {
            dump_packet(data, 'receive')
        }

        this.bus.send('eth-receive-end', [data.length])

        if (this.rxcr & 0x10) {
            // promiscuous
        } else if (
            this.rxcr & 4 &&
            data[0] === 0xff &&
            data[1] === 0xff &&
            data[2] === 0xff &&
            data[3] === 0xff &&
            data[4] === 0xff &&
            data[5] === 0xff
        ) {
            // broadcast
        } else if (this.rxcr & 8 && (data[0] & 1) === 1) {
            // multicast
            // XXX
            return
        } else if (
            data[0] === this.mac[0] &&
            data[1] === this.mac[1] &&
            data[2] === this.mac[2] &&
            data[3] === this.mac[3] &&
            data[4] === this.mac[4] &&
            data[5] === this.mac[5]
        ) {
            // unicast match, intentionally empty
        } else {
            return
        }

        if (this.mac_address_in_state) {
            data = new Uint8Array(data) // make a copy
            translate_mac_address(data, this.mac, this.mac_address_in_state)
        }

        const packet_length = Math.max(60, data.length)

        const offset = this.curpg << 8
        const total_length = packet_length + 4
        const data_start = offset + 4
        let next = this.curpg + 1 + (total_length >> 8)

        const end = offset + total_length

        const needed = 1 + (total_length >> 8)

        // boundary == curpg interpreted as ringbuffer empty
        const available =
            this.boundary > this.curpg
                ? this.boundary - this.curpg
                : this.pstop - this.curpg + this.boundary - this.pstart

        if (
            available < needed &&
            this.boundary !== 0 // XXX: ReactOS sets this to 0 initially and never updates it unless it receives a packet
        ) {
            dbg_log(
                'Buffer full, dropping packet pstart=' +
                    h(this.pstart) +
                    ' pstop=' +
                    h(this.pstop) +
                    ' curpg=' +
                    h(this.curpg) +
                    ' needed=' +
                    h(needed) +
                    ' boundary=' +
                    h(this.boundary) +
                    ' available=' +
                    h(available),
                LOG_NET,
            )
            return
        }

        if (end > this.pstop << 8) {
            // Shouldn't happen because at this size it can't cross a page,
            // so we can skip filling with zeroes
            dbg_assert(data.length >= 60)

            const cut = (this.pstop << 8) - data_start
            dbg_assert(cut >= 0)

            this.memory.set(data.subarray(0, cut), data_start)
            this.memory.set(data.subarray(cut), this.pstart << 8)
            dbg_log('rcv cut=' + h(cut), LOG_NET)
        } else {
            this.memory.set(data, data_start)

            if (data.length < 60) {
                this.memory.fill(0, data_start + data.length, data_start + 60)
            }
        }

        if (next >= this.pstop) {
            next += this.pstart - this.pstop
        }

        // write packet header
        this.memory[offset] = ENRSR_RXOK // status
        this.memory[offset + 1] = next
        this.memory[offset + 2] = total_length
        this.memory[offset + 3] = total_length >> 8

        this.curpg = next

        dbg_log(
            'rcv offset=' +
                h(offset) +
                ' len=' +
                h(total_length) +
                ' next=' +
                h(next),
            LOG_NET,
        )

        this.do_interrupt(ENISR_RX)
    }

    get_page(): number {
        return (this.cr >> 6) & 3
    }
}