import { byte, word } from 'js/types';
import { debug, toHex } from 'js/util';
import ApplesoftDump from 'js/applesoft/decompiler';
import IntegerBASICDump from 'js/intbasic/decompiler';
import { MassStorageData, NibbleDisk } from '../types';
import { readSector, writeSector } from '../format_utils';

/** Usual track for VTOC */
export const DEFAULT_VTOC_TRACK = 0x11;

/** Usual sector for VTOC */
export const DEFAULT_VTOC_SECTOR = 0x00;

/** Usual track, sector for VTOC */
export const DEFAULT_VTOC_TRACK_SECTOR = {
    track: DEFAULT_VTOC_TRACK,
    sector: DEFAULT_VTOC_SECTOR,
} as const;

/**
 * VTOC sector offsets
 */
export const VTOC_OFFSETS = {
    CATALOG_TRACK: 0x01,
    CATALOG_SECTOR: 0x02,
    VERSION: 0x03,
    VOLUME: 0x06,
    TRACK_SECTOR_LIST_SIZE: 0x27,
    LAST_ALLOCATION_TRACK: 0x30,
    ALLOCATION_DIRECTION: 0x31,
    TRACK_COUNT: 0x34,
    SECTOR_COUNT: 0x35,
    SECTOR_BYTE_COUNT_LOW: 0x36,
    SECTOR_BYTE_COUNT_HIGH: 0x37,
    FREE_SECTOR_MAP: 0x38,
} as const;

/**
 * Catalog sector offsets
 */
export const CATALOG_OFFSETS = {
    NEXT_CATALOG_TRACK: 0x01,
    NEXT_CATALOG_SECTOR: 0x02,
    ENTRY1: 0x0B,
    ENTRY2: 0x2E,
    ENTRY3: 0x51,
    ENTRY4: 0x74,
    ENTRY5: 0x97,
    ENTRY6: 0xBA,
    ENTRY7: 0xDD,
} as const;

/**
 * Catalog entry offsets
 */
export const CATALOG_ENTRY_OFFSETS = {
    SECTOR_LIST_TRACK: 0x00,
    SECTOR_LIST_SECTOR: 0x01,
    FILE_TYPE: 0x02,
    FILE_NAME: 0x03,
    DELETED_FILE_TRACK: 0x20,
    FILE_LENGTH_LOW: 0x21,
    FILE_LENGTH_HIGH: 0x22,
} as const;

export const CATALOG_ENTRY_LENGTH = 0x23;

/**
 * VTOC Data
 */
export interface VTOC {
    catalog: {
        track: byte;
        sector: byte;
    };
    version: byte;
    volume: byte;
    trackSectorListSize: byte;
    lastAllocationTrack: byte;
    allocationDirection: byte;
    trackCount: byte;
    sectorCount: byte;
    sectorByteCount: byte;
    trackSectorMap: boolean[][];
}

/**
 * Track and sector data
 */
export interface TrackSector {
    track: byte;
    sector: byte;
}

/**
 * File entry data
 */
export interface FileEntry {
    locked: boolean;
    deleted: boolean;
    type: string;
    size: number;
    name: string;
    trackSectorList: TrackSector;
}

/**
 * File data
 */
export interface FileData {
    address: word;
    data: Uint8Array;
}

function isNibbleDisk(disk: NibbleDisk | MassStorageData): disk is NibbleDisk {
    return !!((disk as NibbleDisk).encoding);
}

/**
 * DOS 3.3 Volume object.
 */
export class DOS33 {
    private vtoc: VTOC;
    private files: FileEntry[];

    /**
     * Constructor can take either a nibblized disk, or a raw data
     * object returned by MassStorage.getBinary()
     *
     * @param disk Nibble disk or MassStorageData object
     */
    constructor(private disk: NibbleDisk | MassStorageData) {
        this.vtoc = this.readVolumeTOC();
    }

    /**
     * Method to read or write a sector, could be overloaded to support other
     * data types.
     *
     * @param track Track to read/write
     * @param sector Sector to read/write
     * @param data If present, sector data to write
     *
     * @returns data read or written
     */
    rwts(track: byte, sector: byte, data?: Uint8Array): Uint8Array {
        if (data) {
            if (isNibbleDisk(this.disk)) {
                writeSector(this.disk, track, sector, data);
            } else {
                const offset = track * 0x1000 + sector * 0x100;
                new Uint8Array(this.disk.data).set(data, offset);
            }
        } else {
            if (isNibbleDisk(this.disk)) {
                data = readSector(this.disk, track, sector);
            } else {
                const offset = track * 0x1000 + sector * 0x100;
                // Slice new array so modifications to apply to original track
                data = new Uint8Array(this.disk.data.slice(offset, offset + 0x100));
            }
        }
        return data;
    }

    /**
     * Creates a classic hex and ascii dump of a sector
     *
     * @param track Track to dump
     * @param sector Sector to dump
     * @returns String representation of sector
     */
    dumpSector(track: byte, sector: byte) {
        let result = '';
        const data = this.rwts(track, sector);
        let b;
        for (let idx = 0; idx < 16; idx++) {
            result += toHex(idx << 4) + ': ';
            for (let jdx = 0; jdx < 16; jdx++) {
                b = data[idx * 16 + jdx];
                result += toHex(b) + ' ';
            }
            result += '        ';
            for (let jdx = 0; jdx < 16; jdx++) {
                b = data[idx * 16 + jdx] & 0x7f;
                if (b >= 0x20 && b < 0x7f) {
                    result += String.fromCharCode(b);
                } else {
                    result += '.';
                }
            }
            result += '\n';
        }
        return result;
    }

    /**
     * Returns all the track sector pairs for a file.
     *
     * @param file File to read
     * @param full Also return track sector map entries
     * @returns Array of file track and sectors
     */
    readFileTrackSectorList(file: FileEntry, full?: boolean) {
        const fileTrackSectorList = [];
        let { track, sector } = file.trackSectorList;
        while (track || sector) {
            if (full) {
                fileTrackSectorList.push({ track, sector });
            }
            let jdx = 0; // offset in sector
            const data = this.rwts(track, sector);
            track = data[0x01];
            sector = data[0x02];
            let offset = 0x0C; // offset in data
            while ((data[offset] || data[offset + 1]) && jdx < 121) {
                fileTrackSectorList.push({
                    track: data[offset],
                    sector: data[offset + 1]
                });
                offset += 2;
                jdx++;
            }
        }
        return fileTrackSectorList;
    }

    /**
     * Read a file from disk
     *
     * @param file File entry to read
     * @returns Data for file, and load address if binary
     */
    readFile(file: FileEntry): FileData {
        let data: byte[] = [];
        let idx;
        const fileTrackSectorList = this.readFileTrackSectorList(file);
        for (idx = 0; idx < fileTrackSectorList.length; idx++) {
            const { track, sector } = fileTrackSectorList[idx];
            data = data.concat([...this.rwts(track, sector)]);
        }
        let offset = 0;
        let length = 0;
        let address = 0;

        switch (file.type) {
            case 'I':
            case 'A':
                offset = 2;
                length = data[0] | data[1] << 8;
                break;
            case 'T':
                length = 0;
                while (data[length]) { length++; }
                break;
            case 'B':
                offset = 4;
                address = data[0] | data[1] << 8;
                length = data[2] | data[3] << 8;
                break;
        }

        data = data.slice(offset, offset + length);

        return { data: new Uint8Array(data), address };
    }

    /**
     * Allocate a new sector for a file in the allocation list
     *
     * @returns track and sector pair
     */
    allocateSector(): TrackSector {
        const { vtoc } = this;
        const findSector = (track: byte) => {
            const sectorMap = vtoc.trackSectorMap[track];
            return sectorMap.findIndex((sector: boolean) => sector);
        };

        const lastTrack = vtoc.lastAllocationTrack;
        let track = lastTrack;
        let sector = findSector(track);
        while (sector === -1) {
            if (vtoc.allocationDirection === 0x01) {
                track = track - 1;
                if (track < 0) {
                    track = vtoc.catalog.track;
                    vtoc.allocationDirection = 0xff;
                }
            } else {
                track = track + 1;
                if (track >= vtoc.trackCount) {
                    throw new Error('Insufficient free space');
                }
            }
            sector = findSector(track);
        }

        vtoc.lastAllocationTrack = track;
        vtoc.trackSectorMap[track][sector] = false;

        return { track, sector };
    }

    /**
     * Compute free sector count.
     *
     * @returns count of free sectors
     */
    freeSectorCount() {
        return this.vtoc.trackSectorMap.reduce((count, flags) => (
            count + flags.reduce((count, flag) => (
                count + (flag ? 1 : 0)
            ), 0)
        ), 0);
    }

    /**
     * Compute used sector count
     *
     * @returns used sector count
     */
    usedSectorCount() {
        return this.vtoc.trackSectorMap.reduce((count, flags) => (
            count + flags.reduce((count, flag) => (
                count + (flag ? 0 : 1)
            ), 0)
        ), 0);
    }

    /**
     * Writes a file to disk. If new file the file entry must also be
     * added to the catalog.
     *
     * @param file File to write
     * @param fileData File data to write, including address if binary
     */
    writeFile(file: FileEntry, fileData: FileData) {
        let prefix: byte[] = [];
        let { data } = fileData;
        switch (file.type) {
            case 'A':
            case 'I':
                prefix = [
                    data.length % 0x100,
                    data.length >> 8
                ];
                break;
            case 'B':
                prefix = [
                    fileData.address % 0x100,
                    fileData.address >> 8,
                    data.length % 0x100,
                    data.length >> 8
                ];
                break;
        }
        data = new Uint8Array(prefix.length + data.length);
        data.set(prefix);
        data.set(data, prefix.length);

        const { sectorByteCount, trackSectorListSize } = this.vtoc;
        const dataRequiredSectors = Math.ceil(data.length / sectorByteCount);
        const fileSectorListRequiredSectors = Math.ceil(dataRequiredSectors / trackSectorListSize);
        const requiredSectors = dataRequiredSectors + fileSectorListRequiredSectors;
        let idx;
        let sectors: TrackSector[] = [];

        if (file.trackSectorList) {
            sectors = this.readFileTrackSectorList(file, true);
        }
        if (sectors.length > requiredSectors) {
            for (idx = requiredSectors; idx < sectors.length; idx++) {
                const { track, sector } = sectors[idx];
                this.vtoc.trackSectorMap[track][sector] = true;
            }
            sectors = sectors.slice(0, requiredSectors);
        }
        if (sectors.length < requiredSectors) {
            for (idx = sectors.length; idx < requiredSectors; idx++) {
                sectors.push(this.allocateSector());
            }
        }
        file.trackSectorList = { ...sectors[0] };
        file.size = requiredSectors;

        let jdx = 0;
        let lastTrackSectorList = null;

        for (idx = 0; idx < dataRequiredSectors; idx++) {
            let sector: TrackSector;
            let sectorData;

            const { trackSectorListSize } = this.vtoc;
            if (idx % trackSectorListSize === 0) {
                sector = sectors.shift() as TrackSector;
                sectorData = new Uint8Array();
                if (lastTrackSectorList) {
                    lastTrackSectorList[0x01] = sector.track;
                    lastTrackSectorList[0x02] = sector.sector;
                }
                sectorData[0x05] = idx & 0xff;
                sectorData[0x06] = idx >> 8;
                for (jdx = 0; jdx < trackSectorListSize && jdx < sectors.length; jdx++) {
                    const offset = 0xC + jdx * 2;
                    sectorData[offset] = sectors[jdx].track;
                    sectorData[offset + 1] = sectors[jdx].sector;
                }
                lastTrackSectorList = sectorData;
                this.rwts(sector.track, sector.sector, new Uint8Array(sectorData));
            }

            sector = sectors.shift() as TrackSector;
            sectorData = new Uint8Array(0x100);
            sectorData.set(data.slice(0, 0x100));
            data = data.slice(0x100);
            this.rwts(sector.track, sector.sector, sectorData);
        }
        this.writeVolumeTOC();
        this.writeCatalog();
    }

    /**
     * Convert a file into a string that can be displayed.
     *
     * @param file File to convert
     * @returns A string representing the file
     */
    dumpFile(file: FileEntry) {
        let result = null;
        const fileData = this.readFile(file);
        switch (file.type) {
            case 'A':
                result = new ApplesoftDump(fileData.data, 0).decompile();
                break;
            case 'I':
                result = new IntegerBASICDump(fileData.data).toString();
                break;
            case 'T':
                result = '';
                for (let idx = 0; idx < fileData.data.length; idx++) {
                    const char = fileData.data[idx] & 0x7f;
                    if (char < 0x20) {
                        if (char === 0xd) { // CR
                            result += '\n';
                        } else {
                            result += `$${toHex(char)}`;
                        }
                    } else {
                        result += String.fromCharCode(char);
                    }
                }
                break;
            case 'B':
            default: {
                result = '';
                let hex = '';
                let ascii = '';
                for (let idx = 0; idx < fileData.data.length; idx++) {
                    const val = fileData.data[idx];
                    if (idx % 16 === 0) {
                        if (idx !== 0) {
                            result += `${hex}    ${ascii}\n`;
                        }
                        hex = '';
                        ascii = '';
                        result += `${toHex(fileData.address + idx, 4)}:`;
                    }
                    hex += ` ${toHex(val)}`;
                    ascii += (val & 0x7f) >= 0x20 ? String.fromCharCode(val & 0x7f) : '.';
                }
                result += '\n';
            } break;
        }
        return result;
    }

    /**
     * Read VTOC data from disk
     *
     * @param trackSector Track and sector to read from, or default
     * @returns VTOC
     */
    readVolumeTOC(trackSector: TrackSector = DEFAULT_VTOC_TRACK_SECTOR) {
        const data = this.rwts(trackSector.track, trackSector.sector);
        this.vtoc = {
            catalog: {
                track: data[VTOC_OFFSETS.CATALOG_TRACK],
                sector: data[VTOC_OFFSETS.CATALOG_SECTOR]
            },
            version: data[VTOC_OFFSETS.VERSION],
            volume: data[VTOC_OFFSETS.VOLUME],
            trackSectorListSize: data[VTOC_OFFSETS.TRACK_SECTOR_LIST_SIZE],
            lastAllocationTrack: data[VTOC_OFFSETS.LAST_ALLOCATION_TRACK],
            allocationDirection: data[VTOC_OFFSETS.ALLOCATION_DIRECTION],
            trackCount: data[VTOC_OFFSETS.TRACK_COUNT],
            sectorCount: data[VTOC_OFFSETS.SECTOR_COUNT],
            sectorByteCount: data[VTOC_OFFSETS.SECTOR_BYTE_COUNT_LOW] |
                (data[VTOC_OFFSETS.SECTOR_BYTE_COUNT_HIGH] << 8),
            trackSectorMap: []
        };

        for (let idx = 0; idx < this.vtoc.trackCount; idx++) {
            const sectorMap = [];
            const offset = 0x38 + idx * 4;
            let bitmap =
                (data[offset] << 24) |
                (data[offset + 1] << 16) |
                (data[offset + 2] << 8) |
                data[offset + 3];

            for (let jdx = 0; jdx < this.vtoc.sectorCount; jdx++) {
                sectorMap.unshift(!!(bitmap & 0x80000000));
                bitmap <<= 1;
            }
            this.vtoc.trackSectorMap.push(sectorMap);
        }

        debug(`DISK VOLUME ${this.vtoc.volume}`);

        return this.vtoc;
    }

    /**
     * Write VTOC data back to disk.
     *
     * @param trackSector Track and sector to read from, or default
     */
    writeVolumeTOC(trackSector: TrackSector = DEFAULT_VTOC_TRACK_SECTOR) {
        const { vtoc } = this;
        const data = new Uint8Array(0x100).fill(0);
        data[VTOC_OFFSETS.CATALOG_TRACK] = vtoc.catalog.track;
        data[VTOC_OFFSETS.CATALOG_SECTOR] = vtoc.catalog.sector;
        data[VTOC_OFFSETS.VERSION] = vtoc.version || 3;
        data[VTOC_OFFSETS.VOLUME] = vtoc.volume || 0xFE;
        data[VTOC_OFFSETS.TRACK_SECTOR_LIST_SIZE] = vtoc.trackSectorListSize || 0x7a;
        data[VTOC_OFFSETS.LAST_ALLOCATION_TRACK] = vtoc.lastAllocationTrack;
        data[VTOC_OFFSETS.ALLOCATION_DIRECTION] = vtoc.allocationDirection;
        data[VTOC_OFFSETS.TRACK_COUNT] = vtoc.trackCount;
        data[VTOC_OFFSETS.SECTOR_COUNT] = vtoc.sectorCount;
        data[VTOC_OFFSETS.SECTOR_BYTE_COUNT_LOW] = vtoc.sectorByteCount & 0xff;
        data[VTOC_OFFSETS.SECTOR_BYTE_COUNT_HIGH] = vtoc.sectorByteCount >> 8;

        for (let idx = 0; idx < vtoc.trackSectorMap.length; idx++) {
            const offset = 0x38 + idx * 4;
            const sectorMap = vtoc.trackSectorMap[idx];

            let mask = 0;
            for (let jdx = 0; jdx < sectorMap.length; jdx++) {
                mask >>= 1;
                if (sectorMap[jdx]) {
                    mask |= 0x80000000;
                }
            }

            data[offset] = (mask >> 24) & 0xff;
            data[offset + 1] = (mask >> 16) & 0xff;
            data[offset + 2] = (mask >> 8) & 0xff;
            data[offset + 3] = mask & 0xff;
        }
        this.rwts(trackSector.track, trackSector.sector, data);
    }

    /**
     * Reads catalog from disk.
     *
     * @returns Catalog entries
     */
    readCatalog(): FileEntry[] {
        const { catalog } = this.vtoc;
        this.files = [];

        let catTrack = catalog.track;
        let catSector = catalog.sector;
        while (catSector || catTrack) {
            const data = this.rwts(catTrack, catSector);

            catTrack = data[CATALOG_OFFSETS.NEXT_CATALOG_TRACK];
            catSector = data[CATALOG_OFFSETS.NEXT_CATALOG_SECTOR];

            for (let idx = CATALOG_OFFSETS.ENTRY1; idx < 0x100; idx += CATALOG_ENTRY_LENGTH) {
                const file: FileEntry = {
                    locked: false,
                    deleted: false,
                    type: 'A',
                    size: 0,
                    name: '',
                    trackSectorList: { track: 0, sector: 0 },
                };
                let str = '';
                const entry = data.slice(idx, idx + CATALOG_ENTRY_LENGTH);

                if (!entry[CATALOG_ENTRY_OFFSETS.SECTOR_LIST_TRACK]) {
                    continue;
                }

                file.trackSectorList = {
                    track: entry[CATALOG_ENTRY_OFFSETS.SECTOR_LIST_TRACK],
                    sector: entry[CATALOG_ENTRY_OFFSETS.SECTOR_LIST_SECTOR]
                };

                if (file.trackSectorList.track === 0xff) {
                    file.deleted = true;
                    file.trackSectorList.track = entry[CATALOG_ENTRY_OFFSETS.DELETED_FILE_TRACK];
                }

                // Locked
                if (entry[CATALOG_ENTRY_OFFSETS.FILE_TYPE] & 0x80) {
                    file.locked = true;
                }

                str += file.locked ? '*' : ' ';

                // File type
                switch (entry[CATALOG_ENTRY_OFFSETS.FILE_TYPE] & 0x7f) {
                    case 0x00:
                        file.type = 'T';
                        break;
                    case 0x01:
                        file.type = 'I';
                        break;
                    case 0x02:
                        file.type = 'A';
                        break;
                    case 0x04:
                        file.type = 'B';
                        break;
                    case 0x08:
                        file.type = 'S';
                        break;
                    case 0x10:
                        file.type = 'R';
                        break;
                    case 0x20:
                        file.type = 'A';
                        break;
                    case 0x40:
                        file.type = 'B';
                        break;
                }
                str += file.type;
                str += ' ';

                // Size
                file.size = entry[CATALOG_ENTRY_OFFSETS.FILE_LENGTH_LOW] |
                    entry[CATALOG_ENTRY_OFFSETS.FILE_LENGTH_HIGH] << 8;
                str += Math.floor(file.size / 100);
                str += Math.floor(file.size / 10) % 10;
                str += file.size % 10;
                str += ' ';

                // Filename
                for (let jdx = CATALOG_ENTRY_OFFSETS.FILE_NAME; jdx < 0x21; jdx++) {
                    file.name += String.fromCharCode(entry[jdx] & 0x7f);
                }
                str += file.name;
                debug(str);
                this.files.push(file);
            }
        }
        return this.files;
    }

    /**
     * Writes catalog back to disk
     */
    writeCatalog() {
        const { catalog } = this.vtoc;

        let catTrack = catalog.track;
        let catSector = catalog.sector;
        while (catSector || catTrack) {
            const data = this.rwts(catTrack, catSector);

            for (let idx = CATALOG_OFFSETS.ENTRY1; idx < 0x100; idx += CATALOG_ENTRY_OFFSETS.SECTOR_LIST_TRACK) {
                const file = this.files.shift();

                if (!file?.trackSectorList) {
                    continue;
                }

                data[idx + CATALOG_ENTRY_OFFSETS.SECTOR_LIST_TRACK] = file.trackSectorList.track;
                data[idx + CATALOG_ENTRY_OFFSETS.SECTOR_LIST_SECTOR] = file.trackSectorList.sector;

                data[idx + CATALOG_ENTRY_OFFSETS.FILE_TYPE] = file.locked ? 0x80 : 0x00;

                // File type
                switch (file.type) {
                    case 'T':
                        break;
                    case 'I':
                        data[idx + CATALOG_ENTRY_OFFSETS.FILE_TYPE] |= 0x01;
                        break;
                    case 'A':
                        data[idx + CATALOG_ENTRY_OFFSETS.FILE_TYPE] |= 0x02;
                        break;
                    case 'B':
                        data[idx + CATALOG_ENTRY_OFFSETS.FILE_TYPE] |= 0x04;
                        break;
                    case 'S':
                        data[idx + CATALOG_ENTRY_OFFSETS.FILE_TYPE] |= 0x08;
                        break;
                    case 'R':
                        data[idx + CATALOG_ENTRY_OFFSETS.FILE_TYPE] |= 0x10;
                        break;
                }

                // Size
                data[idx + CATALOG_ENTRY_OFFSETS.FILE_LENGTH_LOW] = file.size & 0xff;
                data[idx + CATALOG_ENTRY_OFFSETS.FILE_LENGTH_HIGH] = file.size >> 8;

                // Filename
                for (let jdx = 0; jdx < 0x1E; jdx++) {
                    data[idx + CATALOG_ENTRY_OFFSETS.FILE_NAME + jdx] = file.name.charCodeAt(jdx) | 0x80;
                }
            }
            this.rwts(catTrack, catSector, data);

            catTrack = data[CATALOG_OFFSETS.NEXT_CATALOG_TRACK];
            catSector = data[CATALOG_OFFSETS.NEXT_CATALOG_SECTOR];
        }
    }

    /**
     * Return the volume number from the VTOC
     *
     * @returns Volume number
     */
    getVolumeNumber() {
        return this.vtoc.volume;
    }
}

/**
 * Very lose check for DOS disks, currently simply checks for the
 * version byte in the probable VTOC.
 *
 * @param disk Image to check for DOS
 * @returns true if VTOC version byte is 3
 */
export function isMaybeDOS33(disk: NibbleDisk | MassStorageData) {
    let data;
    if (isNibbleDisk(disk)) {
        data = readSector(disk, DEFAULT_VTOC_TRACK, DEFAULT_VTOC_SECTOR);
    } else if (disk.data.byteLength > 0) {
        data = new Uint8Array(
            disk.data,
            DEFAULT_VTOC_TRACK * 4096 + DEFAULT_VTOC_SECTOR * 0x100,
            0x100
        );
    } else {
        return false;
    }
    return data[VTOC_OFFSETS.VERSION] === 3;
}