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(_ settings: LocalizedSettingsFile) -> LocalizedSettings {
        .init(navigationBarIconDescription: settings.navigationBarIconDescription,
              posts: .init(
                title: settings.posts.feedTitle,
                description: settings.posts.feedDescription,
                feedUrlPrefix: settings.posts.feedUrlPrefix))
    }

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

        let settings = try storage.loadSettings()
        let imageDescriptions = storage.loadImageDescriptions().reduce(into: [:]) { descriptions, description in
            descriptions[description.imageId] = description
        }

        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] = []

        for (file, url) in filesData {
            let ext = file.components(separatedBy: ".").last!.lowercased()
            let type = FileType(fileExtension: ext)
            if case .image(let type) = type {
                let descriptions = imageDescriptions[file]
                images[file] = ImageResource(
                    type: type,
                    uniqueId: file,
                    en: descriptions?.english ?? "",
                    de: descriptions?.german ?? "",
                    fileUrl: url)
            } else {
                files.append(FileResource(type: type, uniqueId: file, description: ""))
            }
        }

        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.posts = posts.sorted(ascending: false) { $0.startDate }
        self.settings = makeSettings(settings, tags: tags)
    }

    private func makeSettings(_ settings: SettingsFile, tags: [String : Tag]) -> Settings {

        let navigationBar = NavigationBarSettings(
            iconPath: settings.navigationBar.navigationIconPath,
            tags: settings.navigationBar.navigationTags.map { tags[$0]! })

        let posts = PostSettings(
            postsPerPage: settings.posts.postsPerPage,
            contentWidth: settings.posts.contentWidth)

        let pages = PageSettings(
            pageUrlPrefix: settings.pages.pageUrlPrefix,
            contentWidth: settings.pages.contentWidth)

        return Settings(
            outputDirectoryPath: settings.outputDirectoryPath,
            navigationBar: navigationBar,
            posts: posts,
            pages: pages,
            german: convert(settings.german),
            english: convert(settings.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]! })
        }
    }

}