import Foundation

final class Tag: Item {

    var id: String {
        english.urlComponent
    }

    @Published
    var isVisible: Bool

    @Published
    var german: LocalizedTag

    @Published
    var english: LocalizedTag

    init(content: Content, id: String) {
        self.isVisible = true
        self.english = .init(urlComponent: id, name: id)
        let deId = id + "-" + ContentLanguage.german.rawValue
        self.german = .init(urlComponent: deId, name: deId)
        super.init(content: content)
    }

    init(content: Content, isVisible: Bool = true, german: LocalizedTag, english: LocalizedTag) {
        self.isVisible = isVisible
        self.german = german
        self.english = english
        super.init(content: content)
    }

    var linkName: String {
        id.lowercased().replacingOccurrences(of: " ", with: "-")
    }

    var url: String {
        "/tags/\(linkName).html"
    }

    func localized(in language: ContentLanguage) -> LocalizedTag {
        switch language {
        case .english: return english
        case .german: return german
        }
    }

    // MARK: Paths

    func absoluteUrl(for language: ContentLanguage) -> String {
        makeCleanAbsolutePath(internalPath(for: language))
    }

    func filePathRelativeToOutputFolder(for language: ContentLanguage) -> String {
        makeCleanRelativePath(internalPath(for: language))
    }

    private func internalPath(for language: ContentLanguage) -> String {
        content.settings.pages.pageUrlPrefix + "/" + localized(in: language).urlComponent
    }
}

extension Tag: Identifiable {
    
}

extension Tag: Equatable {

    static func == (_ lhs: Tag, _ rhs: Tag) -> Bool {
        lhs.id == rhs.id
    }
}

extension Tag: Hashable {

    func hash(into hasher: inout Hasher) {
        hasher.combine(id)
    }
}

extension Tag: Comparable {

    static func < (lhs: Tag, rhs: Tag) -> Bool {
        lhs.id < rhs.id
    }
}