ReadViewSDK/Sources/RDEpubReaderView/ReaderView/Paging/RDEpubReaderSpreadResolver.swift

import Foundation

struct RDEpubReaderSpreadResolver {

    func isFullScreenPage(
        _ pageNum: Int,
        landscapeDualPageEnabled: Bool,
        isLandscape: Bool,
        coverPageIndex: Int?
    ) -> Bool {
        guard landscapeDualPageEnabled, isLandscape, let coverIndex = coverPageIndex else { return false }
        return pageNum == coverIndex
    }

    func dualPagePair(
        for pageNum: Int,
        totalPages: Int,
        coverPageIndex: Int?
    ) -> (left: Int, right: Int?) {
        if let coverIndex = coverPageIndex {
            if pageNum == coverIndex {
                return (coverIndex, nil)
            }
            let adjustedIndex = pageNum - (coverIndex + 1)
            let pairStart = coverIndex + 1 + (adjustedIndex / 2) * 2
            let left = pairStart
            let right = pairStart + 1 < totalPages ? pairStart + 1 : nil
            return (left, right)
        }

        let left = (pageNum / 2) * 2
        let right = left + 1 < totalPages ? left + 1 : nil
        return (left, right)
    }

    func adjacentDualPage(
        from pageNum: Int,
        totalPages: Int,
        coverPageIndex: Int?,
        forward: Bool
    ) -> Int? {
        let pair = dualPagePair(for: pageNum, totalPages: totalPages, coverPageIndex: coverPageIndex)
        if forward {
            let nextStart = (pair.right ?? pair.left) + 1
            return nextStart < totalPages ? nextStart : nil
        }

        let prevEnd = pair.left - 1
        guard prevEnd >= 0 else { return nil }
        return dualPagePair(for: prevEnd, totalPages: totalPages, coverPageIndex: coverPageIndex).left
    }

    func nextPage(
        from currentPage: Int,
        totalPages: Int,
        pagesPerScreen: Int,
        coverPageIndex: Int?,
        forward: Bool
    ) -> Int? {
        if pagesPerScreen > 1 {
            return adjacentDualPage(
                from: currentPage,
                totalPages: totalPages,
                coverPageIndex: coverPageIndex,
                forward: forward
            )
        }

        let target = currentPage + (forward ? 1 : -1)
        guard target >= 0, target < totalPages else { return nil }
        return target
    }
}