# -*- coding: utf-8 -*-
################################################################################
#
#    Cybrosys Technologies Pvt. Ltd.
#
#    Copyright (C) 2024-TODAY Cybrosys Technologies(<https://www.cybrosys.com>).
#    Author: Sabeel B (odoo@cybrosys.com)
#
#    You can modify it under the terms of the GNU AFFERO
#    GENERAL PUBLIC LICENSE (AGPL v3), Version 3.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU AFFERO GENERAL PUBLIC LICENSE (AGPL v3) for more details.
#
#    You should have received a copy of the GNU AFFERO GENERAL PUBLIC LICENSE
#    (AGPL v3) along with this program.
#    If not, see <http://www.gnu.org/licenses/>.
#
################################################################################
import babel.dates
import pytz
import itertools
from werkzeug.exceptions import NotFound
from collections import OrderedDict
from odoo.http import request
from odoo.tools import lazy
from odoo import http, fields
from odoo.addons.website.controllers.main import QueryURL
from odoo.addons.http_routing.models.ir_http import slug, unslug
from odoo.addons.website_sale.controllers.main import TableCompute, WebsiteSale
from odoo.tools import sql
from odoo.tools.misc import get_lang


class WebsiteShop(WebsiteSale):
    """Shop Controller"""

    @http.route(['/shop/config/website'], type='json', auth='user')
    def _change_website_config(self, **options):
        """Alter Website Config"""
        if not request.env.user.has_group(
                'website.group_website_restricted_editor'):
            raise NotFound()
        current_website = request.env['website'].get_current_website()
        writable_fields = {
            'shop_ppg', 'shop_ppr', 'shop_default_sort',
            'product_page_image_layout', 'product_page_image_width',
            'product_page_grid_columns', 'product_page_image_spacing'
        }
        if 'ppg' in options and not options['ppg']:
            options['ppg'] = 1
        if 'product_page_grid_columns' in options:
            options['product_page_grid_columns'] = int(
                options['product_page_grid_columns'])
        write_vals = {k: v for k, v in options.items() if k in writable_fields}
        if write_vals:
            current_website.write(write_vals)
        current_website.select = True

    @http.route()
    def shop(self, page=0, category=None, search='', min_price=0.0,
             max_price=0.0, ppg=False, **post):
        """Shop Page Configuration"""
        current_website = request.env['website'].get_current_website()
        if not current_website.select:
            ppg = 12
            ppr = 3
            res = super(WebsiteShop, self).shop(page=page, category=category,
                                                search=search,
                                                min_price=min_price,
                                                max_price=max_price, ppg=ppg,
                                                **post)
            products = res.qcontext['products']
            res.qcontext.update({
                'bins': lazy(
                    lambda: TableCompute().process(products, ppg, ppr)),
                'ppr': ppr,
            })
            return res
        else:
            ppg = current_website.shop_ppg
            ppr = current_website.shop_ppr
            res = super(WebsiteShop, self).shop(page=page, category=category,
                                                search=search,
                                                min_price=min_price,
                                                max_price=max_price, ppg=ppg,
                                                **post)
            products = res.qcontext['products']
            res.qcontext.update({
                'bins': lazy(
                    lambda: TableCompute().process(products, ppg, ppr)),
                'ppr': ppr,
            })
            current_website.select = True
            return res


class WebsiteBlog(http.Controller):

    def nav_list(self, blog=None):
        """Website Blog"""
        dom = blog and [('blog_id', '=', blog.id)] or []
        if not request.env.user.has_group('website.group_website_designer'):
            dom += [('post_date', '<=', fields.Datetime.now())]
        groups = request.env['blog.post']._read_group_raw(
            dom,
            ['name', 'post_date'],
            groupby=["post_date"], orderby="post_date desc")
        for group in groups:
            (r, label) = group['post_date']
            start, end = r.split('/')
            group['post_date'] = label
            group['date_begin'] = start
            group['date_end'] = end

            locale = get_lang(request.env).code
            start = pytz.UTC.localize(fields.Datetime.from_string(start))
            tzinfo = pytz.timezone(request.context.get('tz', 'utc') or 'utc')

            group['month'] = babel.dates.format_datetime(start, format='MMMM',
                                                         tzinfo=tzinfo,
                                                         locale=locale)
            group['year'] = babel.dates.format_datetime(start, format='yyyy',
                                                        tzinfo=tzinfo,
                                                        locale=locale)

        return OrderedDict((year, [m for m in months]) for year, months in
                           itertools.groupby(groups, lambda g: g['year']))

    @http.route([
        '''/blog/<model("blog.blog"):blog>/
        <model("blog.post", "[('blog_id','=',blog.id)]"):blog_post>''',
    ], type='http', auth="public", website=True, sitemap=True)
    def blog_post(self, blog, blog_post, tag_id=None, page=1,
                  enable_editor=None, **post):
        """ Prepare all values to display the blog.

        :return dict values: values for the templates, containing

         - 'blog_post': browse of the current post
         - 'blog': browse of the current blog
         - 'blogs': list of browse records of blogs
         - 'tag': current tag, if tag_id in parameters
         - 'tags': all tags, for tag-based navigation
         - 'pager': a pager on the comments
         - 'nav_list': a dict [year][month] for archives navigation
         - 'next_post': next blog post, to direct the user towards the next
         interesting post
        """
        BlogPost = request.env['blog.post']
        date_begin, date_end = post.get('date_begin'), post.get('date_end')

        domain = request.website.website_domain()
        blogs = blog.search(domain, order="create_date, id asc")

        tag = None
        if tag_id:
            tag = request.env['blog.tag'].browse(int(tag_id))
        blog_url = QueryURL('', ['blog', 'tag'], blog=blog_post.blog_id,
                            tag=tag, date_begin=date_begin, date_end=date_end)

        if not blog_post.blog_id.id == blog.id:
            return request.redirect(
                "/blog/%s/%s" % (slug(blog_post.blog_id), slug(blog_post)),
                code=301)

        tags = request.env['blog.tag'].search([])

        # Find next Post
        blog_post_domain = [('blog_id', '=', blog.id)]
        if not request.env.user.has_group('website.group_website_designer'):
            blog_post_domain += [('post_date', '<=', fields.Datetime.now())]

        all_post = BlogPost.search(blog_post_domain)

        if blog_post not in all_post:
            return request.redirect("/blog/%s" % (slug(blog_post.blog_id)))

        # should always return at least the current post
        all_post_ids = all_post.ids
        current_blog_post_index = all_post_ids.index(blog_post.id)
        nb_posts = len(all_post_ids)
        next_post_id = all_post_ids[
            (current_blog_post_index + 1) % nb_posts] if nb_posts > 1 else None
        next_post = next_post_id and BlogPost.browse(next_post_id) or False
        prev_post_id = all_post_ids[
            (current_blog_post_index - 1) % nb_posts] if nb_posts > 1 else None
        prev_post = next_post_id and BlogPost.browse(prev_post_id) or False

        values = {
            'tags': tags,
            'tag': tag,
            'blog': blog,
            'blog_post': blog_post,
            'blogs': blogs,
            'main_object': blog_post,
            'enable_editor': enable_editor,
            'next_post': next_post,
            'date': date_begin,
            'blog_url': blog_url,
            'prev_post': prev_post,
        }
        response = request.render("website_blog.blog_post_complete", values)

        if blog_post.id not in request.session.get('posts_viewed', []):
            if sql.increment_fields_skiplock(blog_post, 'visits'):
                if not request.session.get('posts_viewed'):
                    request.session['posts_viewed'] = []
                request.session['posts_viewed'].append(blog_post.id)
                request.session.modified = True
        return response