# Design документы для CouchDB с поддержкой мультидоменности и мультиязычности

module.exports =
    # Design документ для настроек доменов
    domains:
        version: "3.0"
        views:
            # Все настройки доменов
            all_domains:
                map: ((doc) ->
                    if doc.type is 'domain_settings'
                        emit(doc.domain, doc)
                ).toString()
            
            # Активные домены
            active_domains:
                map: ((doc) ->
                    if doc.type is 'domain_settings' and doc.active is true
                        emit(doc.domain, doc)
                ).toString()
            
            # Домены по приоритету
            by_priority:
                map: ((doc) ->
                    if doc.type is 'domain_settings' and doc.active is true
                        emit(doc.priority or 0, doc)
                ).toString()

    # Design документ для блог постов с мультидоменностью и мультиязычностью
    blog_posts:
        version: "3.0"
        views:
            # Все опубликованные блог посты с фильтром по домену и языку
            published:
                map: ((doc) ->
                    if doc.type is 'blog_post' and doc.status is 'published'
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, language, doc.created_at], doc)
                ).toString()
            
            # Блог посты по тегам с фильтром по домену и языку
            by_tag:
                map: ((doc) ->
                    if doc.type is 'blog_post' and doc.status is 'published' and doc.tags
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        for tag in doc.tags
                            emit([domain, language, tag, doc.created_at], doc)
                ).toString()
            
            # Блог посты по автору с фильтром по домену и языку
            by_author:
                map: ((doc) ->
                    if doc.type is 'blog_post' and doc.status is 'published'
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, language, doc.author, doc.created_at], doc)
                ).toString()
            
            # Блог посты по категории с фильтром по домену и языку
            by_category:
                map: ((doc) ->
                    if doc.type is 'blog_post' and doc.status is 'published' and doc.category_id
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, language, doc.category_id, doc.created_at], doc)
                ).toString()
            
            # Переводы блог постов
            translations:
                map: ((doc) ->
                    if doc.type is 'blog_post' and doc.translation_of
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, doc.translation_of, language], doc)
                ).toString()
            
            # Поиск по заголовку и содержанию с фильтром по домену и языку
            search:
                map: ((doc) ->
                    if doc.type is 'blog_post' and doc.status is 'published'
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        text = (doc.title + " " + doc.content + " " + doc.excerpt).toLowerCase()
                        words = text.split(/\W+/).filter (word) -> word.length > 2
                        
                        for word in words
                            emit([domain, language, word], {
                                _id: doc._id
                                title: doc.title
                                excerpt: doc.excerpt
                                created_at: doc.created_at
                                domain: doc.domain
                                language: doc.language
                            })
                ).toString()

    # Design документ для мероприятий с мультидоменностью и мультиязычностью
    events:
        version: "3.0"
        views:
            # Все мероприятия по дате с фильтром по домену и языку
            by_date:
                map: ((doc) ->
                    if doc.type is 'event'
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, language, doc.event_date], doc)
                ).toString()
            
            # Предстоящие мероприятия с фильтром по домену и языку
            upcoming:
                map: ((doc) ->
                    if doc.type is 'event' and doc.status is 'upcoming'
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, language, doc.event_date], doc)
                ).toString()
            
            # Активные мероприятия с фильтром по домену и языку
            ongoing:
                map: ((doc) ->
                    if doc.type is 'event' and doc.status is 'ongoing'
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, language, doc.event_date], doc)
                ).toString()
            
            # Мероприятия по тегам с фильтром по домену и языку
            by_tag:
                map: ((doc) ->
                    if doc.type is 'event' and doc.tags
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        for tag in doc.tags
                            emit([domain, language, tag, doc.event_date], doc)
                ).toString()
            
            # Мероприятия по местоположению с фильтром по домену и языку
            by_location:
                map: ((doc) ->
                    if doc.type is 'event'
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, language, doc.location, doc.event_date], doc)
                ).toString()
            
            # Переводы мероприятий
            translations:
                map: ((doc) ->
                    if doc.type is 'event' and doc.translation_of
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, doc.translation_of, language], doc)
                ).toString()

    # Design документ для слайдов с мультидоменностью и мультиязычностью
    slides:
        version: "3.0"
        views:
            # Активные слайды по порядку с фильтром по домену и языку
            active_ordered:
                map: ((doc) ->
                    if doc.type is 'slide' and doc.active is true
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, language, doc.order], doc)
                ).toString()
            
            # Переводы слайдов
            translations:
                map: ((doc) ->
                    if doc.type is 'slide' and doc.translation_of
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, doc.translation_of, language], doc)
                ).toString()

    # Design документ для товаров с мультидоменностью и мультиязычностью
    products:
        version: "3.0"
        views:
            # Все доступные товары с фильтром по домену и языку
            available:
                map: ((doc) ->
                    if doc.type is 'product' and doc.status is 'available'
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, language, doc.created_at], doc)
                ).toString()
            
            # Товары по категориям с фильтром по домену и языку
            by_category:
                map: ((doc) ->
                    if doc.type is 'product' and doc.status is 'available'
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, language, doc.category_id, doc.created_at], doc)
                ).toString()
            
            # Товары по тегам с фильтром по домену и языку
            by_tag:
                map: ((doc) ->
                    if doc.type is 'product' and doc.tags
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        for tag in doc.tags
                            emit([domain, language, tag, doc.created_at], doc)
                ).toString()
            
            # Товары по цене с фильтром по домену и языку
            by_price:
                map: ((doc) ->
                    if doc.type is 'product' and doc.status is 'available'
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, language, doc.price], doc)
                ).toString()
            
            # Переводы товаров
            translations:
                map: ((doc) ->
                    if doc.type is 'product' and doc.translation_of
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, doc.translation_of, language], doc)
                ).toString()

    # Design документ для категорий и тем с мультидоменностью и мультиязычностью
    categories_themes:
        version: "3.0"
        views:
            # Все категории по порядку с фильтром по домену и языку
            categories_ordered:
                map: ((doc) ->
                    if doc.type is 'category'
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, language, doc.order], doc)
                ).toString()
            
            # Категории по родителю с фильтром по домену и языку
            categories_by_parent:
                map: ((doc) ->
                    if doc.type is 'category'
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        parent = doc.parent_id or 'root'
                        emit([domain, language, parent, doc.order], doc)
                ).toString()
            
            # Все темы с фильтром по домену и языку
            themes:
                map: ((doc) ->
                    if doc.type is 'theme'
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, language, doc.name], doc)
                ).toString()
            
            # Переводы категорий
            category_translations:
                map: ((doc) ->
                    if doc.type is 'category' and doc.translation_of
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, doc.translation_of, language], doc)
                ).toString()
            
            # Переводы тем
            theme_translations:
                map: ((doc) ->
                    if doc.type is 'theme' and doc.translation_of
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, doc.translation_of, language], doc)
                ).toString()

    # Design документ для страниц с мультидоменностью и мультиязычностью
    pages:
        version: "3.0"
        views:
            # Все страницы по slug с фильтром по домену и языку
            by_slug:
                map: ((doc) ->
                    if doc.type is 'page'
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, language, doc.slug], doc)
                ).toString()
            
            # Опубликованные страницы с фильтром по домену и языку
            published:
                map: ((doc) ->
                    if doc.type is 'page' and doc.status is 'published'
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, language, doc.order or 0], doc)
                ).toString()
            
            # Страницы по родителю с фильтром по домену и языку
            by_parent:
                map: ((doc) ->
                    if doc.type is 'page'
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        parent = doc.parent_id or 'root'
                        emit([domain, language, parent, doc.order or 0], doc)
                ).toString()
            
            # Переводы страниц
            translations:
                map: ((doc) ->
                    if doc.type is 'page' and doc.translation_of
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, doc.translation_of, language], doc)
                ).toString()

    # Design документ для меню с мультидоменностью и мультиязычностью
    menus:
        version: "3.0"
        views:
            # Меню по локации с фильтром по домену и языку
            by_location:
                map: ((doc) ->
                    if doc.type is 'menu'
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, language, doc.location], doc)
                ).toString()
            
            # Активные меню с фильтром по домену и языку
            active:
                map: ((doc) ->
                    if doc.type is 'menu' and doc.active is true
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, language, doc.location], doc)
                ).toString()
            
            # Переводы меню
            translations:
                map: ((doc) ->
                    if doc.type is 'menu' and doc.translation_of
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, doc.translation_of, language], doc)
                ).toString()

    # Design документ для настроек с мультидоменностью и мультиязычностью
    settings:
        version: "3.0"
        views:
            # Настройки по ключу с фильтром по домену и языку
            by_key:
                map: ((doc) ->
                    if doc.type is 'setting'
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, language, doc.key], doc)
                ).toString()
            
            # Глобальные настройки (без привязки к языку)
            global:
                map: ((doc) ->
                    if doc.type is 'setting' and doc.is_global is true
                        domain = doc.domain or 'default'
                        emit([domain, doc.key], doc)
                ).toString()

    # Design документ для пользователей
    users:
        version: "3.0"
        views:
            # Пользователи по email
            by_email:
                map: ((doc) ->
                    if doc.type is 'user'
                        emit(doc.email, doc)
                ).toString()
            
            # Пользователи по роли
            by_role:
                map: ((doc) ->
                    if doc.type is 'user'
                        emit(doc.role, doc)
                ).toString()
            
            # Активные пользователи
            active:
                map: ((doc) ->
                    if doc.type is 'user' and doc.active is true
                        emit(doc.email, doc)
                ).toString()
            
            # Пользователи по языку предпочтения
            by_language:
                map: ((doc) ->
                    if doc.type is 'user' and doc.preferences?.language
                        emit(doc.preferences.language, doc)
                ).toString()

    # Design документ для заказов с мультидоменностью
    orders:
        version: "3.0"
        views:
            # Заказы по статусу с фильтром по домену
            by_status:
                map: ((doc) ->
                    if doc.type is 'order'
                        domain = doc.domain or 'default'
                        emit([domain, doc.status, doc.created_at], doc)
                ).toString()
            
            # Заказы по пользователю с фильтром по домену
            by_user:
                map: ((doc) ->
                    if doc.type is 'order'
                        domain = doc.domain or 'default'
                        emit([domain, doc.user_id, doc.created_at], doc)
                ).toString()
            
            # Заказы по языку
            by_language:
                map: ((doc) ->
                    if doc.type is 'order'
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, language, doc.created_at], doc)
                ).toString()

    # Design документ для переводов контента
    translations:
        version: "3.0"
        views:
            # Все переводы по исходному документу
            by_source:
                map: ((doc) ->
                    if doc.translation_of
                        domain = doc.domain or 'default'
                        emit([domain, doc.translation_of, doc.language], doc)
                ).toString()
            
            # Переводы по типу контента
            by_content_type:
                map: ((doc) ->
                    if doc.translation_of
                        domain = doc.domain or 'default'
                        emit([domain, doc.type, doc.translation_of, doc.language], doc)
                ).toString()
            
            # Статусы переводов
            by_status:
                map: ((doc) ->
                    if doc.translation_of and doc.translation_status
                        domain = doc.domain or 'default'
                        emit([domain, doc.translation_status, doc.language], doc)
                ).toString()

    # Design документ для глобального поиска с мультидоменностью и мультиязычностью
    global_search:
        version: "3.0"
        views:
            # Глобальный поиск по всем типам документов с фильтром по домену и языку
            all_content:
                map: ((doc) ->
                    searchFields = {}
                    domain = doc.domain or 'default'
                    language = doc.language or 'ru'
                    
                    switch doc.type
                        when 'blog_post'
                            if doc.status is 'published'
                                searchFields =
                                    title: doc.title
                                    content: doc.content
                                    excerpt: doc.excerpt
                                    author: doc.author
                                    tags: doc.tags
                                    type: 'blog_post'
                        
                        when 'event'
                            searchFields =
                                title: doc.title
                                content: doc.content
                                location: doc.location
                                tags: doc.tags
                                type: 'event'
                        
                        when 'product'
                            if doc.status is 'available'
                                searchFields =
                                    title: doc.title
                                    content: doc.content
                                    excerpt: doc.excerpt
                                    category: doc.category
                                    tags: doc.tags
                                    type: 'product'
                        
                        when 'category', 'theme'
                            searchFields =
                                name: doc.name
                                description: doc.description
                                type: doc.type
                        
                        when 'page'
                            if doc.status is 'published'
                                searchFields =
                                    title: doc.title
                                    content: doc.content
                                    type: 'page'
                    
                    # Создаем поисковый индекс
                    if searchFields.title
                        text = (
                            searchFields.title + " " + 
                            (searchFields.content or "") + " " +
                            (searchFields.excerpt or "") + " " +
                            (searchFields.author or "") + " " +
                            (searchFields.location or "") + " " +
                            (searchFields.description or "")
                        ).toLowerCase()
                        
                        # Добавляем теги
                        if searchFields.tags
                            text += " " + searchFields.tags.join(" ")
                        
                        words = text.split(/\W+/).filter (word) -> word.length > 2
                        
                        for word in words
                            emit([domain, language, word], {
                                _id: doc._id
                                type: searchFields.type
                                title: searchFields.title
                                excerpt: searchFields.excerpt
                                created_at: doc.created_at
                                domain: domain
                                language: language
                            })
                ).toString()

    # Design документ для статистики с мультидоменностью и мультиязычностью
    statistics:
        version: "3.0"
        views:
            # Статистика по типам документов с фильтром по домену и языку
            by_type:
                map: ((doc) ->
                    domain = doc.domain or 'default'
                    language = doc.language or 'ru'
                    emit([domain, language, doc.type], 1)
                ).toString()
                reduce: ((keys, values) ->
                    sum values
                ).toString()
            
            # Статистика просмотров блог постов с фильтром по домену и языку
            blog_views:
                map: ((doc) ->
                    if doc.type is 'blog_post'
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, language, doc._id], doc.views or 0)
                ).toString()
                reduce: ((keys, values) ->
                    sum values
                ).toString()
            
            # Статистика мероприятий по статусу с фильтром по домену и языку
            events_by_status:
                map: ((doc) ->
                    if doc.type is 'event'
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        emit([domain, language, doc.status], 1)
                ).toString()
                reduce: ((keys, values) ->
                    sum values
                ).toString()
            
            # Статистика продаж товаров с фильтром по домену и языку
            product_sales:
                map: ((doc) ->
                    if doc.type is 'order' and doc.items
                        domain = doc.domain or 'default'
                        language = doc.language or 'ru'
                        for item in doc.items
                            emit([domain, language, item.product_id], item.quantity)
                ).toString()
                reduce: ((keys, values) ->
                    sum values
                ).toString()
            
            # Статистика по языкам
            by_language:
                map: ((doc) ->
                    if doc.language
                        domain = doc.domain or 'default'
                        emit([domain, doc.language, doc.type], 1)
                ).toString()
                reduce: ((keys, values) ->
                    sum values
                ).toString()

    # Design документ для ревизий и аудита
    audit:
        version: "3.0"
        views:
            # Логи изменений по дате
            by_date:
                map: ((doc) ->
                    if doc.type is 'audit_log'
                        emit(doc.created_at, doc)
                ).toString()
            
            # Логи по пользователю
            by_user:
                map: ((doc) ->
                    if doc.type is 'audit_log'
                        emit([doc.user_id, doc.created_at], doc)
                ).toString()
            
            # Логи по действию
            by_action:
                map: ((doc) ->
                    if doc.type is 'audit_log'
                        emit([doc.action, doc.created_at], doc)
                ).toString()
            
            # Логи по языку
            by_language:
                map: ((doc) ->
                    if doc.type is 'audit_log' and doc.language
                        emit([doc.language, doc.created_at], doc)
                ).toString()