package be.simplenotes.domain.usecases

import arrow.core.Either
import be.simplenotes.domain.model.Note
import be.simplenotes.domain.model.PersistedNote
import be.simplenotes.domain.model.PersistedNoteMetadata
import be.simplenotes.domain.security.HtmlSanitizer
import be.simplenotes.domain.usecases.markdown.MarkdownConverter
import be.simplenotes.domain.usecases.markdown.MarkdownParsingError
import be.simplenotes.domain.usecases.repositories.NoteRepository
import java.util.*

class NoteService(
    private val markdownConverter: MarkdownConverter,
    private val noteRepository: NoteRepository,
) {

    fun create(userId: Int, markdownText: String): Either<MarkdownParsingError, PersistedNote> =
        markdownConverter
            .renderDocument(markdownText)
            .map { it.copy(html = HtmlSanitizer.sanitize(it.html)) }
            .map { Note(it.metadata, markdown = markdownText, html = it.html) }
            .map { noteRepository.create(userId, it) }

    fun update(userId: Int, uuid: UUID, markdownText: String): Either<MarkdownParsingError, PersistedNote?> =
        markdownConverter
            .renderDocument(markdownText)
            .map { it.copy(html = HtmlSanitizer.sanitize(it.html)) }
            .map { Note(it.metadata, markdown = markdownText, html = it.html) }
            .map { noteRepository.update(userId, uuid, it) }

    fun paginatedNotes(
        userId: Int,
        page: Int,
        itemsPerPage: Int = 20,
        tag: String? = null,
        deleted: Boolean = false
    ): PaginatedNotes {
        val count = noteRepository.count(userId, tag, deleted)
        val offset = (page - 1) * itemsPerPage
        val numberOfPages = (count / itemsPerPage) + 1
        val notes = if (count == 0) emptyList() else noteRepository.findAll(userId, itemsPerPage, offset, tag, deleted)
        return PaginatedNotes(numberOfPages, notes)
    }

    fun find(userId: Int, uuid: UUID) = noteRepository.find(userId, uuid)
    fun trash(userId: Int, uuid: UUID) = noteRepository.delete(userId, uuid, permanent = false)
    fun restore(userId: Int, uuid: UUID) = noteRepository.restore(userId, uuid)
    fun delete(userId: Int, uuid: UUID) = noteRepository.delete(userId, uuid, permanent = true)
    fun countDeleted(userId: Int) = noteRepository.count(userId, deleted = true)

}

data class PaginatedNotes(val pages: Int, val notes: List<PersistedNoteMetadata>)