# app/services/CategoryService.coffee
{ Category } = require 'app/types/data'

class CategoryService
  constructor: ->
    @pouchService = require 'app/utils/pouch'
    @initialized = false

  init: ->
    return Promise.resolve() if @initialized
    
    try
      await @pouchService.init()
      @initialized = true
      log '✅ CategoryService инициализирован'
      return Promise.resolve()
    catch error
      log '❌ Ошибка инициализации CategoryService: ' + error
      return Promise.reject(error)

    # В app/services/CategoryService.coffee обновите метод getAllCategories:
  getAllCategories: ->
      await @ensureInit()
      
      try
        result = await @pouchService.queryView('categories', 'all_active', {
          include_docs: true
        })
        
        categories = result.rows.map (row) ->
          # Используем конструктор Category с данными из базы
          debug.dir row
          d = new Category(row.doc)
          debug.dir d
          return d
        
        # Сортировка по порядку
        categories.sort (a, b) -> (a.order or 0) - (b.order or 0)
        
        log '📂 Загружены категории: '+categories.length
        return categories
      catch error
        log '❌ Ошибка загрузки категорий: '+error.message
        throw error

  getCategoryBySlug: (slug) ->
    await @ensureInit()
    
    try
      result = await @pouchService.queryView('categories', 'by_slug', {
        key: slug
        include_docs: true
      })
      
      if result.rows.length > 0
        category = new Category(result.rows[0].doc)
        log '📂 Загружена категория по slug: ' + slug
        return category
      else
        log '⚠️ Категория не найдена по slug: ' + slug
        return null
    catch error
      log '❌ Ошибка поиска категории по slug ' + slug + ': ' + error
      throw error

  getCategoryById: (id) ->
    await @ensureInit()
    
    try
      doc = await @pouchService.getDocument(id)
      category = new Category(doc)
      log '📂 Загружена категория по ID: ' + id
      return category
    catch error
      if error.status == 404
        log '⚠️ Категория не найдена по ID: ' + id
        return null
      else
        log '❌ Ошибка загрузки категории по ID ' + id + ': ' + error
        throw error

  getHierarchicalCategories: ->
    await @ensureInit()
    
    try
      result = await @pouchService.queryView('categories', 'hierarchical', {
        include_docs: true
      })
      
      categories = result.rows.map (row) ->
        new Category(row.doc)
      
      # Построение иерархии
      hierarchical = @buildHierarchy(categories)
      
      log '🌳 Построена иерархия категорий'
      return hierarchical
    catch error
      log '❌ Ошибка построения иерархии категорий: ' + error
      throw error

  deleteCategory: (categoryId) ->
    await @ensureInit()
    
    try
      # Получаем документ для получения _rev
      categoryDoc = await @pouchService.getDocument(categoryId)
      
      # Устанавливаем флаг deleted вместо полного удаления
      categoryDoc.active = false
      categoryDoc.deleted = true
      categoryDoc.updatedAt = new Date().toISOString()
      
      result = await @pouchService.saveDocument(categoryDoc)
      log '✅ Категория помечена как удаленная: '+categoryId
      return result
    catch error
      if error.status == 404
        log '⚠️ Категория не найдена для удаления: '+categoryId
        throw new Error('Категория не найдена')
      else if error.status == 403
        log '🚫 Доступ запрещен при удалении категории: '+error.message
        throw new Error('Нет прав для удаления категории: '+error.message)
      else
        log '❌ Ошибка удаления категории: '+error.message
        throw error

  buildHierarchy: (categories, parentId = null) ->
    hierarchy = []
    
    categories
      .filter (cat) -> cat.parent == parentId
      .sort (a, b) -> a.order - b.order
      .forEach (category) =>
        children = @buildHierarchy(categories, category._id)
        if children.length > 0
          category.children = children
        hierarchy.push(category)
    
    return hierarchy

  saveCategory: (categoryData) ->
    await @ensureInit()
    
    try
      # Если переданы данные, создаем объект Category
      if categoryData instanceof Category
        category = categoryData
      else
        category = new Category(categoryData)
      
      # Генерация ID если не установлен
      if not category._id
        category._id = 'category:' + category.slug
      
      # Убедимся, что есть все обязательные поля
      category.type = 'category'
      category.active = category.active != false
      category.domains = category.domains || [window.location.hostname]
      category.order = category.order || 0
      category.createdAt = category.createdAt || new Date().toISOString()
      category.updatedAt = new Date().toISOString()
      
      result = await @pouchService.saveDocument(category)
      log '💾 Категория сохранена: ' + category.name + ' (ID: ' + category._id + ')'
      return result
    catch error
      log '❌ Ошибка сохранения категории: ' + error
      throw error

  bulkSaveCategories: (categories) ->
    await @ensureInit()
    
    try
      # Преобразуем категории в документы для PouchDB
      docs = categories.map (category) =>
        if category._id and category._rev
          return category
        else
          # Новая категория
          return {
            _id: category._id || 'category:' + category.slug
            type: 'category'
            name: category.name
            slug: category.slug
            parent: category.parent || null
            order: category.order || 0
            image: category.image || ''
            description: category.description || ''
            domains: category.domains || [window.location.hostname]
            active: category.active != false
            seo: category.seo || {}
            createdAt: category.createdAt || new Date().toISOString()
            updatedAt: new Date().toISOString()
          }
      
      result = await @pouchService.bulkDocs(docs)
      
      success = []
      errors = []
      
      result.forEach (item, index) =>
        if item.ok
          success.push(categories[index])
        else
          errors.push({
            category: categories[index]
            error: item.error || 'Unknown error'
            index: index
          })
      
      log '📦 Пакетное сохранение категорий: успешно ' + success.length + ', ошибок ' + errors.length
      return { success, errors }
      
    catch error
      log '❌ Ошибка пакетного сохранения категорий: ' + error
      throw error

  ensureInit: ->
    unless @initialized
      throw new Error('CategoryService не инициализирован. Вызовите init() сначала.')

module.exports = new CategoryService()