import Foundation
import Ink
import Splash

struct PageContentGenerator {

    private let largeImageIndicator = "*large*"

    private let factory: TemplateFactory

    private let swift = SyntaxHighlighter(format: HTMLOutputFormat())

    private let siteRoot: Element

    private let results: GenerationResultsHandler

    init(factory: TemplateFactory, siteRoot: Element, results: GenerationResultsHandler) {
        self.factory = factory
        self.siteRoot = siteRoot
        self.results = results
    }

    func generate(page: Element, language: String, content: String) -> (content: String, includesCode: Bool) {
        var hasCodeContent = false
        var largeImageCount = 0

        let imageModifier = Modifier(target: .images) { html, markdown in
            processMarkdownImage(markdown: markdown, html: html, page: page, language: language, largeImageCount: &largeImageCount)
        }
        let codeModifier = Modifier(target: .codeBlocks) { html, markdown in
            if markdown.starts(with: "```swift") {
                let code = markdown.between("```swift", and: "```").trimmed
                return "<pre><code>" + swift.highlight(code) + "</pre></code>"
            }
            hasCodeContent = true
            return html
        }
        let linkModifier = Modifier(target: .links) { html, markdown in
            handleLink(page: page, language: language, html: html, markdown: markdown)
        }
        let htmlModifier = Modifier(target: .html) { html, markdown in
            handleHTML(page: page, language: language, html: html, markdown: markdown)
        }

        let parser = MarkdownParser(modifiers: [imageModifier, codeModifier, linkModifier, htmlModifier])
        return (parser.html(from: content), hasCodeContent)
    }

    private func handleLink(page: Element, language: String, html: String, markdown: Substring) -> String {
        let file = markdown.between("(", and: ")")
        if file.hasPrefix("page:") {
            let pageId = file.replacingOccurrences(of: "page:", with: "")
            guard let pagePath = results.getPagePath(for: pageId, source: page.path, language: language) else {
                // Remove link since the page can't be found
                return markdown.between("[", and: "]")
            }
            // Adjust file path to get the page url
            let url = page.relativePathToOtherSiteElement(file: pagePath)
            return html.replacingOccurrences(of: file, with: url)
        }

        if let filePath = page.nonAbsolutePathRelativeToRootForContainedInputFile(file) {
            // The target of the page link must be present after generation is complete
            results.expect(file: filePath, source: page.path)
        }
        return html
    }

    private func handleHTML(page: Element, language: String, html: String, markdown: Substring) -> String {
        // TODO: Check HTML code in markdown for required resources
        //print("[HTML] Found in page \(page.path):")
        //print(markdown)
        // Things to check:
        // <img src=
        // <a href=
        //
        return html
    }

    private func processMarkdownImage(markdown: Substring, html: String, page: Element, language: String, largeImageCount: inout Int) -> String {
        // Split the markdown ![alt](file title)
        // There are several known shorthand commands
        // For images: ![*large* left_title](file right_title)
        // For videos: ![option1,option2,...](file)
        // For svg with custom area: ![x,y,width,height](file.svg)
        // For downloads: ![download](file1, text1; file2, text2, ...)
        // For a simple boxes: ![box](title;body)
        // A fancy page link: ![page](page_id)
        // External pages: ![external](url1, text1; url2, text2, ...)
        let fileAndTitle = markdown.between("(", and: ")")
        let alt = markdown.between("[", and: "]").nonEmpty
        if let alt = alt, let command = ShorthandMarkdownKey(rawValue: alt) {
            return handleShortHandCommand(command, page: page, language: language, content: fileAndTitle)
        }

        let file = fileAndTitle.dropAfterFirst(" ")
        let title = fileAndTitle.contains(" ") ? fileAndTitle.dropBeforeFirst(" ").nonEmpty : nil

        let fileExtension = file.lastComponentAfter(".").lowercased()
        if let _ = ImageType(fileExtension: fileExtension) {
            return handleImage(page: page, file: file, rightTitle: title, leftTitle: alt, largeImageCount: &largeImageCount)
        }
        if let _ = VideoType(rawValue: fileExtension) {
            return handleVideo(page: page, file: file, optionString: alt)
        }
        switch fileExtension {
        case "svg":
            return handleSvg(page: page, file: file, area: alt)
        case "gif":
            return handleGif(page: page, file: file, altText: alt ?? "gif image")
        default:
            return handleFile(page: page, file: file, fileExtension: fileExtension)
        }
    }

    private func handleShortHandCommand(_ command: ShorthandMarkdownKey, page: Element, language: String, content: String) -> String {
        switch command {
        case .downloadButtons:
            return handleDownloadButtons(page: page, content: content)
        case .externalLink:
            return handleExternalButtons(page: page, content: content)
        case .includedHtml:
            return handleExternalHTML(page: page, file: content)
        case .box:
            return handleSimpleBox(page: page, content: content)
        case .pageLink:
            return handlePageLink(page: page, language: language, pageId: content)
        }
    }

    private func handleImage(page: Element, file: String, rightTitle: String?, leftTitle: String?, largeImageCount: inout Int) -> String {
        let imagePath = page.pathRelativeToRootForContainedInputFile(file)
        let left: String
        let createFullScreenVersion: Bool
        if let leftTitle {
            createFullScreenVersion = leftTitle.hasPrefix(largeImageIndicator)
            left = leftTitle.dropBeforeFirst(largeImageIndicator).trimmed
        } else {
            left = ""
            createFullScreenVersion = false
        }
        let size = results.requireFullSizeMultiVersionImage(
            source: imagePath,
            destination: imagePath,
            requiredBy: page.path)

        let altText = left.nonEmpty ?? rightTitle ?? "image"

        var content = [PageImageTemplateKey : String]()
        content[.altText] = altText
        content[.image] = file.dropAfterLast(".")
        content[.imageExtension] = file.lastComponentAfter(".")
        content[.width] = "\(Int(size.width))"
        content[.height] = "\(Int(size.height))"
        content[.leftText] = left
        content[.rightText] = rightTitle ?? ""

        guard createFullScreenVersion else {
            return factory.image.generate(content)
        }

        results.requireOriginalSizeImages(
            source: imagePath,
            destination: imagePath,
            requiredBy: page.path)

        largeImageCount += 1
        content[.number] = "\(largeImageCount)"
        return factory.largeImage.generate(content)
    }

    private func handleVideo(page: Element, file: String, optionString: String?) -> String {
        let options: [PageVideoTemplate.VideoOption] = optionString.unwrapped { string in
            string.components(separatedBy: " ").compactMap { optionText -> PageVideoTemplate.VideoOption? in
                guard let optionText = optionText.trimmed.nonEmpty else {
                    return nil
                }
                guard let option = PageVideoTemplate.VideoOption(rawValue: optionText) else {
                    results.warning("Unknown video option \(optionText)", source: page.path)
                    return nil
                }
                return option
            }
        } ?? []
        // TODO: Check page folder for alternative video versions
        let sources: [PageVideoTemplate.VideoSource] = [(url: file, type: .mp4)]

        let filePath = page.pathRelativeToRootForContainedInputFile(file)
        results.require(file: filePath, source: page.path)
        return factory.video.generate(sources: sources, options: options)
    }

    private func handleGif(page: Element, file: String, altText: String) -> String {
        let imagePath = page.pathRelativeToRootForContainedInputFile(file)
        results.require(file: imagePath, source: page.path)

        guard let size = results.getImageSize(atPath: imagePath, source: page.path) else {
            return ""
        }
        let width = Int(size.width)
        let height = Int(size.height)
        return factory.html.image(file: file, width: width, height: height, altText: altText)
    }

    private func handleSvg(page: Element, file: String, area: String?) -> String {
        let imagePath = page.pathRelativeToRootForContainedInputFile(file)
        results.require(file: imagePath, source: page.path)

        guard let size = results.getImageSize(atPath: imagePath, source: page.path) else {
            return "" // Missing image warning already produced
        }
        let width = Int(size.width)
        let height = Int(size.height)

        var altText = "image " + file.lastComponentAfter("/")
        guard let area = area else {
            return factory.html.image(file: file, width: width, height: height, altText: altText)
        }
        let parts = area.components(separatedBy: ",").map { $0.trimmed }
        switch parts.count {
        case 1:
            return factory.html.image(file: file, width: width, height: height, altText: parts[0])
        case 4:
            break
        case 5:
            altText = parts[4]
        default:
            results.warning("Invalid area string for svg image", source: page.path)
            return factory.html.image(file: file, width: width, height: height, altText: altText)
        }
        guard let x = Int(parts[0]),
              let y = Int(parts[1]),
              let partWidth = Int(parts[2]),
              let partHeight = Int(parts[3]) else {
            results.warning("Invalid area string for svg image", source: page.path)
            return factory.html.image(file: file, width: width, height: height, altText: altText)
        }
        let part = SVGSelection(x, y, partWidth, partHeight)
        return factory.html.svgImage(file: file, part: part, width: width, height: height, altText: altText)
    }

    private func handleFile(page: Element, file: String, fileExtension: String) -> String {
        results.warning("Unhandled file \(file) with extension \(fileExtension)", source: page.path)
        return ""
    }

    private func handleDownloadButtons(page: Element, content: String) -> String {
        let buttons = content
            .components(separatedBy: ";")
            .compactMap { button -> (file: String, text: String, downloadName: String?)? in
                let parts = button.components(separatedBy: ",")
                guard parts.count == 2 || parts.count == 3 else {
                    results.warning("Invalid button definition", source: page.path)
                    return nil
                }
                let file = parts[0].trimmed
                let title = parts[1].trimmed
                let downloadName = parts.count == 3 ? parts[2].trimmed : nil

                // Ensure that file is available
                let filePath = page.pathRelativeToRootForContainedInputFile(file)
                results.require(file: filePath, source: page.path)

                return (file, title, downloadName)
            }
        return factory.html.downloadButtons(buttons)
    }

    private func handleExternalButtons(page: Element, content: String) -> String {
        let buttons = content
            .components(separatedBy: ";")
            .compactMap { button -> (url: String, text: String)? in
                let parts = button.components(separatedBy: ",")
                guard parts.count == 2 else {
                    results.warning("Invalid external link definition", source: page.path)
                    return nil
                }
                let url = parts[0].trimmed
                let title = parts[1].trimmed

                return (url, title)
            }
        return factory.html.externalButtons(buttons)
    }

    private func handleExternalHTML(page: Element, file: String) -> String {
        let path = page.pathRelativeToRootForContainedInputFile(file)
        return results.getContentOfRequiredFile(at: path, source: page.path) ?? ""
    }

    private func handleSimpleBox(page: Element, content: String) -> String {
        let parts = content.components(separatedBy: ";")
        guard parts.count > 1 else {
            results.warning("Invalid box specification", source: page.path)
            return ""
        }
        let title = parts[0]
        let text = parts.dropFirst().joined(separator: ";")
        return factory.makePlaceholder(title: title, text: text)
    }

    private func handlePageLink(page: Element, language: String, pageId: String) -> String {
        guard let linkedPage = siteRoot.find(pageId) else {
            // Checking the page path will add it to the missing pages
            _ = results.getPagePath(for: pageId, source: page.path, language: language)
            // Remove link since the page can't be found
            return ""
        }
        var content = [PageLinkTemplate.Key: String]()
        
        content[.title] = linkedPage.title(for: language)
        content[.altText] = ""

        let fullThumbnailPath = linkedPage.thumbnailFilePath(for: language).destination
        // Note: Here we assume that the thumbnail was already used elsewhere, so already generated
        let relativeImageUrl = page.relativePathToOtherSiteElement(file: fullThumbnailPath)
        let metadata = linkedPage.localized(for: language)

        if linkedPage.state.hasThumbnailLink {
            let fullPageUrl = linkedPage.fullPageUrl(for: language)
            let relativePageUrl = page.relativePathToOtherSiteElement(file: fullPageUrl)
            content[.url] = "href=\"\(relativePageUrl)\""
        }

        content[.image] = relativeImageUrl.dropAfterLast(".")
        if let suffix = metadata.thumbnailSuffix {
            content[.title] = factory.html.make(title: metadata.title, suffix: suffix)
        } else {
            content[.title] = metadata.title
        }

        let path = linkedPage.makePath(language: language, from: siteRoot)
        content[.path] = factory.pageLink.makePath(components: path)

        content[.description] = metadata.relatedContentText
        if let parent = linkedPage.findParent(from: siteRoot), parent.thumbnailStyle == .large {
            content[.className] = " related-page-link-large"
        }

        // We assume that the thumbnail images are already required by overview pages.
        return factory.pageLink.generate(content)
    }
}