import Foundation

extension Content {

    private func convert(_ tag: LocalizedTagFile, images: [String : ImageResource]) -> LocalizedTag {
        LocalizedTag(
            urlComponent: tag.urlComponent,
            name: tag.name,
            subtitle: tag.subtitle,
            description: tag.description,
            thumbnail: tag.thumbnail.map { images[$0] },
            originalUrl: tag.originalURL)
    }

    private func convert(_ post: LocalizedPostFile, images: [String : ImageResource]) -> LocalizedPost {
        LocalizedPost(
            title: post.title,
            content: post.content,
            lastModified: post.lastModifiedDate,
            images: post.images.compactMap { images[$0] },
            linkPreviewImage: post.linkPreviewImage.map { images[$0] },
            linkPreviewTitle: post.linkPreviewTitle,
            linkPreviewDescription: post.linkPreviewDescription)
    }

    private func convert(_ page: LocalizedPageFile) -> LocalizedPage {
        LocalizedPage(
            urlString: page.url,
            title: page.title,
            lastModified: page.lastModifiedDate,
            originalUrl: page.originalURL,
            files: Set(page.files),
            externalFiles: Set(page.externalFiles),
            requiredFiles: Set(page.requiredFiles),
            linkPreviewImage: page.linkPreviewImage,
            linkPreviewTitle: page.linkPreviewTitle,
            linkPreviewDescription: page.linkPreviewDescription)
    }

    private func convert(_ websiteData: LocalizedWebsiteDataFile) -> LocalizedWebsiteData {
        .init(title: websiteData.title,
              description: websiteData.description,
              iconDescription: websiteData.iconDescription)
    }

    func loadFromDisk() throws {
        let storage = Storage(baseFolder: URL(filePath: contentPath))

        let websiteData = try storage.loadWebsiteData()

        let tagData = try storage.loadAllTags()
        let pagesData = try storage.loadAllPages()
        let postsData = try storage.loadAllPosts()
        let filesData = try storage.loadAllFiles()

        var images: [String : ImageResource] = [:]
        var files: [FileResource] = []
        var videos: [String] = []

        for (file, url) in filesData {
            let ext = file.components(separatedBy: ".").last!.lowercased()
            let type = FileType(fileExtension: ext)
            switch type {
            case .image:
                images[file] = ImageResource(uniqueId: file, altText: .init(en: "", de: ""), fileUrl: url)
            case .file:
                files.append(FileResource(uniqueId: file, description: ""))
            case .video:
                videos.append(file)
            case .resource:
                break
            }
        }

        let tags = tagData.reduce(into: [:]) { (tags, data) in
            tags[data.key] = Tag(
                isVisible: data.value.isVisible,
                german: convert(data.value.german, images: images),
                english: convert(data.value.english, images: images))
        }

        let pages: [String : Page] = loadPages(pagesData, tags: tags)

        let posts = postsData.map { postId, post in
            let linkedPage = post.linkedPageId.map { pages[$0] }
            let german = convert(post.german, images: images)
            let english = convert(post.english, images: images)

            return Post(
                id: postId,
                isDraft: post.isDraft,
                createdDate: post.createdDate,
                startDate: post.startDate,
                endDate: post.endDate,
                tags: post.tags.map { tags[$0]! },
                german: german,
                english: english,
                linkedPage: linkedPage)
        }

        self.tags = tags.values.sorted()
        self.pages = pages.values.sorted(ascending: false) { $0.startDate }
        self.files = files.sorted { $0.uniqueId }
        self.images = images.values.sorted { $0.id }
        self.videos = videos
        self.posts = posts.sorted(ascending: false) { $0.startDate }
        self.websiteData = WebsiteData(
            navigationTags: websiteData.navigationTags.map { tags[$0]! },
            german: convert(websiteData.german),
            english: convert(websiteData.english))
    }

    private func loadPages(_ pagesData: [String : PageFile], tags: [String : Tag]) -> [String : Page] {
        pagesData.reduce(into: [:]) { pages, data in
            let (pageId, page) = data
            pages[pageId] = Page(
                id: pageId,
                isDraft: page.isDraft,
                createdDate: page.createdDate,
                startDate: page.startDate,
                endDate: page.endDate,
                german: convert(page.german),
                english: convert(page.english),
                tags: page.tags.map { tags[$0]! })
        }
    }

}