/**
 * Copyright (c) 2011-2025 Bill Greiman
 * This file is part of the SdFat library for SD memory cards.
 *
 * MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */
#include "../common/upcase.h"
#include "ExFatLib.h"
#include "ExFatVolume.h"
#ifndef DOXYGEN_SHOULD_SKIP_THIS
//------------------------------------------------------------------------------
static void printHex(print_t *pr, uint8_t h);
static void printHex(print_t *pr, uint16_t val);
static void printHex(print_t *pr, uint32_t val);
static void printHex64(print_t *pr, uint64_t n);
static void println64(print_t *pr, uint64_t n);
//------------------------------------------------------------------------------
static void dmpDirData(print_t *pr, const DirGeneric_t *dir)
{
    for (uint8_t k = 0; k < 31; k++)
    {
        if (k)
        {
            pr->write(' ');
        }
        printHex(pr, dir->data[k]);
    }
    pr->println();
}
//------------------------------------------------------------------------------
static uint16_t exFatDirChecksum(const void *dir, uint16_t checksum)
{
    const uint8_t *data = reinterpret_cast<const uint8_t *>(dir);
    bool skip = data[0] == EXFAT_TYPE_FILE;
    for (size_t i = 0; i < 32; i += (i == 1 && skip ? 3 : 1))
    {
        checksum = ((checksum << 15) | (checksum >> 1)) + data[i];
    }
    return checksum;
}

//------------------------------------------------------------------------------
static uint16_t hashDir(const DirName_t *dir, uint16_t hash)
{
    for (uint8_t i = 0; i < 30; i += 2)
    {
        uint16_t u = getLe16(dir->unicode + i);
        if (!u)
        {
            break;
        }
        uint16_t c = toUpcase(u);
        hash = ((hash << 15) | (hash >> 1)) + (c & 0XFF);
        hash = ((hash << 15) | (hash >> 1)) + (c >> 8);
    }
    return hash;
}
//------------------------------------------------------------------------------
static void printDateTime(print_t *pr, uint32_t timeDate, uint8_t ms, int8_t tz)
{
    fsPrintDateTime(pr, timeDate, ms, tz);
    pr->println();
}
//------------------------------------------------------------------------------
static void printDirBitmap(print_t *pr, const DirBitmap_t *dir)
{
    pr->print(F("dirBitmap: 0x"));
    pr->println(dir->type, HEX);
    pr->print(F("flags: 0x"));
    pr->println(dir->flags, HEX);
    pr->print(F("firstCluster: "));
    pr->println(getLe32(dir->firstCluster));
    pr->print(F("size: "));
    println64(pr, getLe64(dir->size));
}
//------------------------------------------------------------------------------
static void printDirFile(print_t *pr, const DirFile_t *dir)
{
    pr->print(F("dirFile: 0x"));
    pr->println(dir->type, HEX);
    pr->print(F("setCount: "));
    pr->println(dir->setCount);
    pr->print(F("setChecksum: 0x"));
    pr->println(getLe16(dir->setChecksum), HEX);
    pr->print(F("attributes: 0x"));
    pr->println(getLe16(dir->attributes), HEX);
    pr->print(F("createTime: "));
    printDateTime(pr, getLe32(dir->createTime), dir->createTimeMs, dir->createTimezone);
    pr->print(F("modifyTime: "));
    printDateTime(pr, getLe32(dir->modifyTime), dir->modifyTimeMs, dir->modifyTimezone);
    pr->print(F("accessTime: "));
    printDateTime(pr, getLe32(dir->accessTime), 0, dir->accessTimezone);
}
//------------------------------------------------------------------------------
static void printDirLabel(print_t *pr, const DirLabel_t *dir)
{
    pr->print(F("dirLabel: 0x"));
    pr->println(dir->type, HEX);
    pr->print(F("labelLength: "));
    pr->println(dir->labelLength);
    pr->print(F("unicode: "));
    for (size_t i = 0; i < dir->labelLength; i++)
    {
        pr->write(dir->unicode[2 * i]);
    }
    pr->println();
}
//------------------------------------------------------------------------------
static void printDirName(print_t *pr, const DirName_t *dir)
{
    pr->print(F("dirName: 0x"));
    pr->println(dir->type, HEX);
    pr->print(F("unicode: "));
    for (size_t i = 0; i < 30; i += 2)
    {
        uint16_t c = getLe16(dir->unicode + i);
        if (c == 0)
            break;
        if (c < 128)
        {
            pr->print(static_cast<char>(c));
        }
        else
        {
            pr->print("0x");
            pr->print(c, HEX);
        }
        pr->print(' ');
    }
    pr->println();
}
//------------------------------------------------------------------------------
static void printDirStream(print_t *pr, const DirStream_t *dir)
{
    pr->print(F("dirStream: 0x"));
    pr->println(dir->type, HEX);
    pr->print(F("flags: 0x"));
    pr->println(dir->flags, HEX);
    pr->print(F("nameLength: "));
    pr->println(dir->nameLength);
    pr->print(F("nameHash: 0x"));
    pr->println(getLe16(dir->nameHash), HEX);
    pr->print(F("validLength: "));
    println64(pr, getLe64(dir->validLength));
    pr->print(F("firstCluster: "));
    pr->println(getLe32(dir->firstCluster));
    pr->print(F("dataLength: "));
    println64(pr, getLe64(dir->dataLength));
}
//------------------------------------------------------------------------------
static void printDirUpcase(print_t *pr, const DirUpcase_t *dir)
{
    pr->print(F("dirUpcase: 0x"));
    pr->println(dir->type, HEX);
    pr->print(F("checksum: 0x"));
    pr->println(getLe32(dir->checksum), HEX);
    pr->print(F("firstCluster: "));
    pr->println(getLe32(dir->firstCluster));
    pr->print(F("size: "));
    println64(pr, getLe64(dir->size));
}
//------------------------------------------------------------------------------
static void printExFatBoot(print_t *pr, pbs_t *pbs)
{
    const BpbExFat_t *ebs = reinterpret_cast<BpbExFat_t *>(pbs->bpb);
    pr->print(F("bpbSig: 0x"));
    pr->println(getLe16(pbs->signature), HEX);
    pr->print(F("FileSystemName: "));
    pr->write(reinterpret_cast<uint8_t *>(pbs->oemName), 8);
    pr->println();
    for (size_t i = 0; i < sizeof(ebs->mustBeZero); i++)
    {
        if (ebs->mustBeZero[i])
        {
            pr->println(F("mustBeZero error"));
            break;
        }
    }
    pr->print(F("PartitionOffset: 0x"));
    printHex64(pr, getLe64(ebs->partitionOffset));
    pr->print(F("VolumeLength: "));
    println64(pr, getLe64(ebs->volumeLength));
    pr->print(F("FatOffset: 0x"));
    pr->println(getLe32(ebs->fatOffset), HEX);
    pr->print(F("FatLength: "));
    pr->println(getLe32(ebs->fatLength));
    pr->print(F("ClusterHeapOffset: 0x"));
    pr->println(getLe32(ebs->clusterHeapOffset), HEX);
    pr->print(F("ClusterCount: "));
    pr->println(getLe32(ebs->clusterCount));
    pr->print(F("RootDirectoryCluster: "));
    pr->println(getLe32(ebs->rootDirectoryCluster));
    pr->print(F("VolumeSerialNumber: 0x"));
    pr->println(getLe32(ebs->volumeSerialNumber), HEX);
    pr->print(F("FileSystemRevision: 0x"));
    pr->println(getLe32(ebs->fileSystemRevision), HEX);
    pr->print(F("VolumeFlags: 0x"));
    pr->println(getLe16(ebs->volumeFlags), HEX);
    pr->print(F("BytesPerSectorShift: "));
    pr->println(ebs->bytesPerSectorShift);
    pr->print(F("SectorsPerClusterShift: "));
    pr->println(ebs->sectorsPerClusterShift);
    pr->print(F("NumberOfFats: "));
    pr->println(ebs->numberOfFats);
    pr->print(F("DriveSelect: 0x"));
    pr->println(ebs->driveSelect, HEX);
    pr->print(F("PercentInUse: "));
    pr->println(ebs->percentInUse);
}
//------------------------------------------------------------------------------
static void printHex(print_t *pr, uint8_t h)
{
    if (h < 16)
    {
        pr->write('0');
    }
    pr->print(h, HEX);
}
//------------------------------------------------------------------------------
static void printHex(print_t *pr, uint16_t val)
{
    bool space = true;
    for (uint8_t i = 0; i < 4; i++)
    {
        uint8_t h = (val >> (12 - 4 * i)) & 15;
        if (h || i == 3)
        {
            space = false;
        }
        if (space)
        {
            pr->write(' ');
        }
        else
        {
            pr->print(h, HEX);
        }
    }
}
//------------------------------------------------------------------------------
static void printHex(print_t *pr, uint32_t val)
{
    bool space = true;
    for (uint8_t i = 0; i < 8; i++)
    {
        uint8_t h = (val >> (28 - 4 * i)) & 15;
        if (h || i == 7)
        {
            space = false;
        }
        if (space)
        {
            pr->write(' ');
        }
        else
        {
            pr->print(h, HEX);
        }
    }
}
//------------------------------------------------------------------------------
static void printHex64(print_t *pr, uint64_t n)
{
    char buf[17];
    char *str = &buf[sizeof(buf) - 1];
    *str = '\0';
    do
    {
        uint8_t h = n & 15;
        *--str = h < 10 ? h + '0' : h + 'A' - 10;
        n >>= 4;
    } while (n);
    pr->println(str);
}
//------------------------------------------------------------------------------
static void println64(print_t *pr, uint64_t n)
{
    char buf[21];
    char *str = &buf[sizeof(buf) - 1];
    *str = '\0';
    do
    {
        uint64_t m = n;
        n /= 10;
        *--str = m - 10 * n + '0';
    } while (n);
    pr->println(str);
}
//------------------------------------------------------------------------------
static void printMbr(print_t *pr, const MbrSector_t *mbr)
{
    pr->print(F("mbrSig: 0x"));
    pr->println(getLe16(mbr->signature), HEX);
    for (int i = 0; i < 4; i++)
    {
        printHex(pr, mbr->part[i].boot);
        pr->write(' ');
        for (int k = 0; k < 3; k++)
        {
            printHex(pr, mbr->part[i].beginCHS[k]);
            pr->write(' ');
        }
        printHex(pr, mbr->part[i].type);
        pr->write(' ');
        for (int k = 0; k < 3; k++)
        {
            printHex(pr, mbr->part[i].endCHS[k]);
            pr->write(' ');
        }
        pr->print(getLe32(mbr->part[i].startSector), HEX);
        pr->print(' ');
        pr->println(getLe32(mbr->part[i].totalSectors), HEX);
    }
}
//==============================================================================
void ExFatPartition::checkUpcase(print_t *pr)
{
    bool skip = false;
    uint16_t u = 0;
    uint8_t *upcase = nullptr;
    uint32_t size = 0;
    Sector_t sector = clusterStartSector(m_rootDirectoryCluster);
    uint8_t *cache = dataCachePrepare(sector, FsCache::CACHE_FOR_READ);
    if (!cache)
    {
        pr->println(F("read root failed"));
        return;
    }
    const DirUpcase_t *dir = reinterpret_cast<DirUpcase_t *>(cache);

    pr->println(F("\nChecking upcase table"));
    for (size_t i = 0; i < 16; i++)
    {
        if (dir[i].type == EXFAT_TYPE_UPCASE)
        {
            sector = clusterStartSector(getLe32(dir[i].firstCluster));
            size = getLe64(dir[i].size);
            break;
        }
    }
    if (!size)
    {
        pr->println(F("upcase not found"));
        return;
    }
    for (size_t i = 0; i < size / 2; i++)
    {
        if ((i % 256) == 0)
        {
            upcase = dataCachePrepare(sector++, FsCache::CACHE_FOR_READ);
            if (!upcase)
            {
                pr->println(F("read upcase failed"));
                return;
            }
        }
        uint16_t v = getLe16(&upcase[2 * (i & 0XFF)]);
        if (skip)
        {
            pr->print("skip ");
            pr->print(u);
            pr->write(' ');
            pr->println(v);
        }
        if (v == 0XFFFF)
        {
            skip = true;
        }
        else if (skip)
        {
            for (uint16_t k = 0; k < v; k++)
            {
                uint16_t x = toUpcase(u + k);
                if (x != (u + k))
                {
                    printHex(pr, static_cast<uint16_t>(u + k));
                    pr->write(',');
                    printHex(pr, x);
                    pr->println("<<<<<<<<<<<<<<<<<<<<");
                }
            }
            u += v;
            skip = false;
        }
        else
        {
            uint16_t x = toUpcase(u);
            if (v != x)
            {
                printHex(pr, u);
                pr->write(',');
                printHex(pr, x);
                pr->write(',');
                printHex(pr, v);
                pr->println();
            }
            u++;
        }
    }
    pr->println(F("Done checkUpcase"));
}
//------------------------------------------------------------------------------
void ExFatPartition::dmpBitmap(print_t *pr)
{
    pr->println(F("bitmap:"));
    dmpSector(pr, m_clusterHeapStartSector);
}
//------------------------------------------------------------------------------
void ExFatPartition::dmpCluster(print_t *pr, Cluster_t cluster, uint32_t offset, uint32_t count)
{
    Sector_t sector = clusterStartSector(cluster) + offset;
    for (uint32_t i = 0; i < count; i++)
    {
        pr->print(F("\nSector: "));
        pr->println(sector + i, HEX);
        dmpSector(pr, sector + i);
    }
}
//------------------------------------------------------------------------------
void ExFatPartition::dmpFat(print_t *pr, uint32_t start, uint32_t count)
{
    Sector_t sector = m_fatStartSector + start;
    Cluster_t cluster = 128 * start;
    pr->println(F("FAT:"));
    for (uint32_t i = 0; i < count; i++)
    {
        uint8_t *cache = dataCachePrepare(sector + i, FsCache::CACHE_FOR_READ);
        if (!cache)
        {
            pr->println(F("cache read failed"));
            return;
        }
        const uint32_t *fat = reinterpret_cast<uint32_t *>(cache);
        for (size_t k = 0; k < 128; k++)
        {
            if (0 == cluster % 8)
            {
                if (k)
                {
                    pr->println();
                }
                printHex(pr, cluster);
            }
            cluster++;
            pr->write(' ');
            printHex(pr, fat[k]);
        }
        pr->println();
    }
}
//------------------------------------------------------------------------------
void ExFatPartition::dmpSector(print_t *pr, Sector_t sector, uint8_t w)
{
    const uint8_t *cache = dataCachePrepare(sector, FsCache::CACHE_FOR_READ);
    if (!cache)
    {
        pr->println(F("dmpSector failed"));
        return;
    }
    for (uint16_t i = 0; i < m_bytesPerSector; i++)
    {
        if (i % w == 0)
        {
            if (i)
            {
                pr->println();
            }
            printHex(pr, i);
        }
        pr->write(' ');
        printHex(pr, cache[i]);
    }
    pr->println();
}
//------------------------------------------------------------------------------
bool ExFatPartition::printDir(print_t *pr, ExFatFile *file)
{
    DirGeneric_t *dir = nullptr;
    const DirFile_t *dirFile;
    const DirStream_t *dirStream;
    const DirName_t *dirName;
    uint16_t calcHash = 0;
    uint16_t nameHash = 0;
    uint16_t setChecksum = 0;
    uint16_t calcChecksum = 0;
    uint8_t nameLength = 0;
    uint8_t setCount = 0;
    uint8_t nUnicode;

#define RAW_ROOT
#ifndef RAW_ROOT
    while (1)
    {
        uint8_t buf[FS_DIR_SIZE];
        if (file->read(buf, FS_DIR_SIZE) != FS_DIR_SIZE)
        {
            break;
        }
        dir = reinterpret_cast<DirGeneric_t *>(buf);
#else  // RAW_ROOT
    (void)file;
    uint32_t nDir = 1UL << (m_sectorsPerClusterShift + 4);
    Sector_t sector = clusterStartSector(m_rootDirectoryCluster);
    for (uint32_t iDir = 0; iDir < nDir; iDir++)
    {
        size_t i = iDir % 16;
        if (i == 0)
        {
            uint8_t *cache = dataCachePrepare(sector++, FsCache::CACHE_FOR_READ);
            if (!cache)
            {
                return false;
            }
            dir = reinterpret_cast<DirGeneric_t *>(cache);
        }
        else
        {
            dir++;
        }
#endif // RAW_ROOT
        if (dir->type == EXFAT_TYPE_END_DIR)
        {
            break;
        }
        pr->println();

        switch (dir->type)
        {
        case EXFAT_TYPE_BITMAP:
            printDirBitmap(pr, reinterpret_cast<DirBitmap_t *>(dir));
            break;

        case EXFAT_TYPE_UPCASE:
            printDirUpcase(pr, reinterpret_cast<DirUpcase_t *>(dir));
            break;

        case EXFAT_TYPE_LABEL:
            printDirLabel(pr, reinterpret_cast<DirLabel_t *>(dir));
            break;

        case EXFAT_TYPE_FILE:
            dirFile = reinterpret_cast<DirFile_t *>(dir);
            printDirFile(pr, dirFile);
            setCount = dirFile->setCount;
            setChecksum = getLe16(dirFile->setChecksum);
            calcChecksum = exFatDirChecksum(dir, 0);
            break;

        case EXFAT_TYPE_STREAM:
            dirStream = reinterpret_cast<DirStream_t *>(dir);
            printDirStream(pr, dirStream);
            nameLength = dirStream->nameLength;
            nameHash = getLe16(dirStream->nameHash);
            calcChecksum = exFatDirChecksum(dir, calcChecksum);
            setCount--;
            calcHash = 0;
            break;

        case EXFAT_TYPE_NAME:
            dirName = reinterpret_cast<DirName_t *>(dir);
            printDirName(pr, dirName);
            calcChecksum = exFatDirChecksum(dir, calcChecksum);
            nUnicode = nameLength > 15 ? 15 : nameLength;
            calcHash = hashDir(dirName, calcHash);
            nameLength -= nUnicode;
            setCount--;
            if (nameLength == 0 || setCount == 0)
            {
                pr->print(F("setChecksum: 0x"));
                pr->print(setChecksum, HEX);
                if (setChecksum != calcChecksum)
                {
                    pr->print(F(" != calcChecksum: 0x"));
                }
                else
                {
                    pr->print(F(" == calcChecksum: 0x"));
                }
                pr->println(calcChecksum, HEX);
                pr->print(F("nameHash: 0x"));
                pr->print(nameHash, HEX);
                if (nameHash != calcHash)
                {
                    pr->print(F(" != calcHash: 0x"));
                }
                else
                {
                    pr->print(F(" == calcHash: 0x"));
                }
                pr->println(calcHash, HEX);
            }
            break;

        default:
            if (dir->type & EXFAT_TYPE_USED)
            {
                pr->print(F("Unknown dirType: 0x"));
            }
            else
            {
                pr->print(F("Unused dirType: 0x"));
            }
            pr->println(dir->type, HEX);
            dmpDirData(pr, dir);
            break;
        }
    }
    pr->println(F("Done"));
    return true;
}
//------------------------------------------------------------------------------
void ExFatPartition::printFat(print_t *pr)
{
    Cluster_t next;
    pr->println(F("FAT:"));
    for (Cluster_t cluster = 0; cluster < 16; cluster++)
    {
        int8_t status = fatGet(cluster, &next);
        pr->print(cluster, HEX);
        pr->write(' ');
        if (status == 0)
        {
            next = EXFAT_EOC;
        }
        pr->println(next, HEX);
    }
}
//------------------------------------------------------------------------------
void ExFatPartition::printUpcase(print_t *pr)
{
    uint8_t *upcase = nullptr;
    Sector_t sector;
    uint32_t size = 0;
    uint32_t checksum = 0;
    const DirUpcase_t *dir;
    sector = clusterStartSector(m_rootDirectoryCluster);
    upcase = dataCachePrepare(sector, FsCache::CACHE_FOR_READ);
    dir = reinterpret_cast<DirUpcase_t *>(upcase);
    if (!dir)
    {
        pr->println(F("read root dir failed"));
        return;
    }
    for (size_t i = 0; i < 16; i++)
    {
        if (dir[i].type == EXFAT_TYPE_UPCASE)
        {
            sector = clusterStartSector(getLe32(dir[i].firstCluster));
            size = getLe64(dir[i].size);
            break;
        }
    }
    if (!size)
    {
        pr->println(F("upcase not found"));
        return;
    }
    for (uint16_t i = 0; i < size / 2; i++)
    {
        if ((i % 256) == 0)
        {
            upcase = dataCachePrepare(sector++, FsCache::CACHE_FOR_READ);
            if (!upcase)
            {
                pr->println(F("read upcase failed"));
                return;
            }
        }
        if (i % 16 == 0)
        {
            pr->println();
            printHex(pr, i);
        }
        pr->write(' ');
        uint16_t uc = getLe16(&upcase[2 * (i & 0XFF)]);
        printHex(pr, uc);
        checksum = upcaseChecksum(uc, checksum);
    }
    pr->println();
    pr->print(F("checksum: "));
    printHex(pr, checksum);
    pr->println();
}
//------------------------------------------------------------------------------
bool ExFatPartition::printVolInfo(print_t *pr)
{
    uint8_t *cache = dataCachePrepare(0, FsCache::CACHE_FOR_READ);
    if (!cache)
    {
        pr->println(F("read mbr failed"));
        return false;
    }
    const MbrSector_t *mbr = reinterpret_cast<MbrSector_t *>(cache);
    printMbr(pr, mbr);
    Sector_t startSector = getLe32(mbr->part->startSector);
    Sector_t volSize = getLe32(mbr->part->totalSectors);
    if (volSize == 0)
    {
        pr->print(F("bad partition size"));
        return false;
    }
    cache = dataCachePrepare(startSector, FsCache::CACHE_FOR_READ);
    if (!cache)
    {
        pr->println(F("read pbs failed"));
        return false;
    }
    printExFatBoot(pr, reinterpret_cast<pbs_t *>(cache));
    return true;
}
#endif // DOXYGEN_SHOULD_SKIP_THIS
