import SwiftUI
import SFSafeSymbols
import HighlightedTextEditor

struct LocalizedPageContentView: View {

    let pageId: String

    let language: ContentLanguage

    @ObservedObject
    var page: LocalizedPage

    @State
    private var isGeneratingWebsite = false

    @State
    private var pageContent: String = ""

    @State
    private var pageContentUsedForGeneration: String = ""

    @State
    private var generationResults = PageGenerationResults()

    @State
    private var didChangeContent = false

    init(pageId: String, page: LocalizedPage, language: ContentLanguage) {
        self.pageId = pageId
        self.page = page
        self.language = language
    }

    var body: some View {
        VStack(alignment: .leading) {
            TextField("", text: $page.title)
                .font(.title)
                .textFieldStyle(.plain)

            HStack(alignment: .firstTextBaseline) {
                Button(action: loadContent) {
                    Text("Load")
                }
                Button(action: saveContent) {
                    Text("Save")
                }
                Button(action: checkContent) {
                    Text("Check")
                }
                Spacer()
            }
            PageContentResultsView(results: generationResults)
            HighlightedTextEditor(
                text: $pageContent,
                highlightRules: .markdown)
            .onChange(of: pageContent) {
                didChangeContent = true
            }
        }
        .padding()
        .onAppear(perform: loadContent)
        .onDisappear(perform: saveContent)
    }

    private func loadContent() {
        let language = language
        do {
            let content = try page.content.storage.pageContent(for: pageId, language: language)

            guard content != "" else {
                pageContent = "New file"
                DispatchQueue.main.async {
                    didChangeContent = false
                }
                return
            }
            pageContent = content
            checkContent()
        } catch {
            print("Failed to load page content: \(error)")
            pageContent = "Failed to load"
        }
        DispatchQueue.main.async {
            didChangeContent = false
        }
    }

    private func saveContent() {
        guard pageContent != "New file", pageContent != "" else {
            // TODO: Delete file?
            return
        }
        guard didChangeContent else {
            return
        }
        do {
            try page.content.storage.save(pageContent: pageContent, for: pageId, language: language)
            didChangeContent = false
        } catch {
            print("Failed to save content: \(error)")
        }
    }

    private func checkContent() {
        let content = self.pageContent
        guard content != pageContentUsedForGeneration else {
            return
        }
        isGeneratingWebsite = true
        DispatchQueue.global(qos: .background).async {
            let generator = PageContentParser(content: page.content, language: language)
            _ = generator.generatePage(from: content)

            DispatchQueue.main.async {
                self.generationResults = generator.results
                isGeneratingWebsite = false
            }
        }
    }
}