# Part of Odoo. See LICENSE file for full copyright and licensing details.
import base64
import uuid
import zipfile
from io import BytesIO
from urllib.parse import unquote

import qrcode
import qrcode.image.svg

from odoo import _, api, fields, models, release
from odoo.exceptions import AccessError, UserError


class PosConfig(models.Model):
    _inherit = "pos.config"

    def _self_order_kiosk_default_languages(self):
        return self.env["res.lang"].get_installed()

    def _self_order_default_user(self):
        users = self.env["res.users"].search(['|', ('company_ids', 'in', self.env.company.id), ('company_id', '=', False)])
        for user in users:
            if user.sudo().has_group("point_of_sale.group_pos_manager"):
                return user
        return False

    status = fields.Selection(
        [("inactive", "Inactive"), ("active", "Active")],
        string="Status",
        compute="_compute_status",
        store=False,
    )
    self_ordering_url = fields.Char(compute="_compute_self_ordering_url")
    self_ordering_mode = fields.Selection(
        [("nothing", "Disable"), ("consultation", "QR menu"), ("mobile", "QR menu + Ordering"), ("kiosk", "Kiosk")],
        string="Self Ordering Mode",
        default="nothing",
        help="Choose the self ordering mode",
        required=True,
    )
    self_ordering_service_mode = fields.Selection(
        [("counter", "Pickup zone"), ("table", "Table")],
        string="Self Ordering Service Mode",
        default="counter",
        help="Choose the kiosk mode",
        required=True,
    )
    self_ordering_default_language_id = fields.Many2one(
        "res.lang",
        string="Default Language",
        help="Default language for the kiosk mode",
        default=lambda self: self.env["res.lang"].search(
            [("code", "=", self.env.lang)], limit=1
        ),
    )
    self_ordering_available_language_ids = fields.Many2many(
        "res.lang",
        string="Available Languages",
        help="Languages available for the kiosk mode",
        default=_self_order_kiosk_default_languages,
    )
    self_ordering_image_home_ids = fields.Many2many(
        'ir.attachment',
        string="Add images",
        help="Image to display on the self order screen",
        bypass_search_access=True,
    )
    self_ordering_image_background_ids = fields.Many2many(
        'ir.attachment',
        string="Set background image",
        help="Image to be displayed in the background",
        relation="pos_self_order_background_rels",
        bypass_search_access=True,
    )
    self_ordering_default_user_id = fields.Many2one(
        "res.users",
        string="Default User",
        help="Access rights of this user will be used when visiting self order website when no session is open.",
        default=_self_order_default_user,
    )
    self_ordering_pay_after = fields.Selection(
        selection=lambda self: self._compute_selection_pay_after(),
        string="Pay After:",
        default="meal",
        help="Choose when the customer will pay",
        required=True,
    )
    self_ordering_image_brand = fields.Image(
        string="Self Order Kiosk Image Brand",
        help="Image to display on the self order screen",
        max_width=1200,
        max_height=250,
    )
    self_ordering_image_brand_name = fields.Char(
        string="Self Order Kiosk Image Brand Name",
        help="Name of the image to display on the self order screen",
    )
    has_paper = fields.Boolean("Has paper", default=True)
    self_ordering_primary_color = fields.Char(string="Color", default=lambda self: self.env.company.email_secondary_color)

    @api.model
    def _load_pos_self_data_fields(self, pos_config_id):
        return ['id', 'name', 'company_id', 'journal_id', 'payment_method_ids', 'limit_categories',
            'iface_available_categ_ids', 'iface_splitbill', 'module_pos_restaurant', 'self_ordering_mode',
            'self_ordering_service_mode', 'self_ordering_default_language_id', 'self_ordering_available_language_ids',
            'self_ordering_image_home_ids', 'self_ordering_default_user_id', 'self_ordering_pay_after',
            'self_ordering_image_brand', 'self_ordering_image_brand_name', 'currency_id', 'has_paper',
            'floor_ids', 'fiscal_position_ids', 'receipt_header', 'receipt_footer', 'current_session_id',
            'pricelist_id', 'available_pricelist_ids', 'default_fiscal_position_id', 'use_pricelist', 'module_pos_restaurant',
             'rounding_method', 'cash_rounding', 'only_round_cash_method', 'has_active_session',
            'available_preset_ids', 'default_preset_id', 'use_presets', 'iface_tax_included',
            'status', 'self_ordering_image_background_ids', 'preparation_printer_ids', 'default_receipt_printer_id',
            'receipt_printer_ids', 'use_order_printer', 'other_devices', 'pos_snooze_ids', 'self_ordering_primary_color',
            'logo', 'receipt_address', 'phone', 'email', 'website',
        ]

    def _update_access_token(self):
        self.access_token = uuid.uuid4().hex[:16]
        self.floor_ids.table_ids._update_identifier()

    @api.model_create_multi
    def create(self, vals_list):
        self._prepare_self_order_splash_screen(vals_list, is_new=True)
        pos_config_ids = super().create(vals_list)
        pos_config_ids._ensure_public_attachments()
        pos_config_ids._prepare_self_order_custom_btn()
        return pos_config_ids

    @api.model
    def _prepare_self_order_splash_screen(self, vals_list, is_new=False):
        for vals in vals_list:
            if not vals.get('self_ordering_mode'):
                return True

            if not vals.get('self_ordering_image_home_ids'):
                vals['self_ordering_image_home_ids'] = [(0, 0, {
                    'name': image_name,
                    'type': 'url',
                    'url': f'/pos_self_order/static/img/{image_name}',
                    'res_model': 'pos.config',
                }) for image_name in ['landing_01.jpg', 'landing_02.jpg', 'landing_03.jpg']]

            if is_new and not vals.get('self_ordering_image_background_ids'):
                vals['self_ordering_image_background_ids'] = [(0, 0, {
                    'name': "background.jpg",
                    'type': 'url',
                    'url': '/pos_self_order/static/img/kiosk_background.jpg',
                    'res_model': 'pos.config',
                })]

        return True

    def _prepare_self_order_custom_btn(self):
        for record in self:
            exists = record.env['pos_self_order.custom_link'].search_count([
                ('pos_config_ids', 'in', record.id),
                ('url', '=', f'/pos-self/{record.id}/products')
            ])

            if not exists:
                record.env['pos_self_order.custom_link'].create({
                    'name': _('Order Now'),
                    'url': f'/pos-self/{record.id}/products',
                    'pos_config_ids': [(4, record.id)],
                })

    def write(self, vals):
        self._prepare_self_order_splash_screen([vals])
        for record in self:
            if vals.get('self_ordering_mode') == 'kiosk' or (vals.get('pos_self_ordering_mode') == 'mobile' and vals.get('pos_self_ordering_service_mode') == 'counter'):
                vals['self_ordering_pay_after'] = 'each'

            if (not vals.get('module_pos_restaurant') and not record.module_pos_restaurant) and vals.get('self_ordering_mode') == 'mobile':
                vals['self_ordering_pay_after'] = 'each'

            if (
                vals.get('self_ordering_mode') == 'mobile'
                and (
                    vals.get('self_ordering_service_mode') == 'counter'
                    or (record.self_ordering_service_mode == 'counter' and vals.get('self_ordering_service_mode') != 'table')
                )
            ):
                vals['self_ordering_pay_after'] = 'each'

            if vals.get('self_ordering_mode') == 'mobile' and vals.get('self_ordering_pay_after') == 'meal':
                vals['self_ordering_service_mode'] = 'table'

        res = super().write(vals)
        self._ensure_public_attachments()
        self._prepare_self_order_custom_btn()
        return res

    def _ensure_public_attachments(self):
        attachments = self.self_ordering_image_background_ids | self.self_ordering_image_home_ids
        attachments = attachments.filtered(lambda a: not a.public)
        if attachments:
            attachments.sudo().write({"public": True})

    @api.depends("module_pos_restaurant")
    def _compute_self_order(self):
        for record in self:
            if not record.module_pos_restaurant and record.self_ordering_mode != 'kiosk':
                record.self_ordering_mode = 'nothing'

    def _compute_selection_pay_after(self):
        selection_each_label = _("Each Order")
        if not release.version_info[-1]:
            selection_each_label = f"{selection_each_label} {_('(require Odoo Enterprise)')}"
        return [("meal", _("Meal")), ("each", selection_each_label)]

    @api.constrains('self_ordering_default_user_id')
    def _check_default_user(self):
        for record in self:
            if (
                record.self_ordering_mode != 'nothing' and (
                not record.self_ordering_default_user_id or (
                record.self_ordering_default_user_id
                and not record.self_ordering_default_user_id.sudo().has_group("point_of_sale.group_pos_user")
                and not record.self_ordering_default_user_id.sudo().has_group("point_of_sale.group_pos_manager")))
            ):
                raise UserError(_("The Self-Order default user must be a POS user"))

    @api.constrains("payment_method_ids", "self_ordering_mode")
    def _onchange_payment_method_ids(self):
        # TODO: Delete in master
        pass

    def _get_qr_code_data(self):
        self.ensure_one()

        table_qr_code = []
        if self.self_ordering_mode == 'mobile' and self.module_pos_restaurant and self.self_ordering_service_mode == 'table':
            table_qr_code.extend([{
                    'name': floor.name,
                    'type': 'table',
                    'tables': [
                        {
                            'identifier': table.identifier,
                            'id': table.id,
                            'name': table.table_number,
                            'url': self._get_self_order_url(table.id),
                        }
                        for table in floor.table_ids.filtered("active")
                    ]
                }
                for floor in self.floor_ids]
            )
        else:
            # Here we use "range" to determine the number of QR codes to generate from
            # this list, which will then be inserted into a PDF.
            table_qr_code.extend([{
                'name': _('Generic'),
                'type': 'default',
                'tables': [{
                    'id': i,
                    'url': self._get_self_order_url(),
                } for i in range(0, 6)]
            }])

        return table_qr_code

    def _get_self_order_route(self, table_id: int | None = None) -> str:
        self.ensure_one()
        base_route = f"/pos-self/{self.id}"
        table_route = ""

        if self.self_ordering_mode == 'consultation':
            return base_route

        if self.self_ordering_mode == 'mobile':
            table = self.env["restaurant.table"].search(
                [("active", "=", True), ("id", "=", table_id)], limit=1
            )

            if table:
                table_route = f"&table_identifier={table.identifier}"

        return f"{base_route}?access_token={self.access_token}{table_route}"

    def _get_self_order_url(self, table_id: int | None = None) -> str:
        self.ensure_one()
        long_url = self.get_base_url() + self._get_self_order_route(table_id)
        return self.env['link.tracker'].search_or_create([{
            'url': long_url,
            'title': f"Self Order {self.name}" if not table_id else f"Self Order {self.name} - Table id {table_id}",
        }]).short_url

    def preview_self_order_app(self):
        self.ensure_one()
        return {
            "type": "ir.actions.act_url",
            "url": self._get_self_order_route(),
            "target": "new",
        }

    def _load_self_data_models(self):
        return ['pos.session', 'pos.preset', 'resource.calendar.attendance', 'pos.order', 'pos.order.line', 'pos.payment', 'pos.payment.method', 'res.partner',
            'pos.category', 'product.template', 'product.product', 'product.combo', 'product.combo.item', 'res.company', 'account.tax',
            'account.tax.group', 'pos.printer', 'res.country', 'product.category', 'product.pricelist', 'product.pricelist.item', 'res.currency', 'account.fiscal.position',
            'res.lang', 'product.attribute', 'product.attribute.custom.value', 'product.template.attribute.line', 'product.template.attribute.value', 'product.tag',
            'decimal.precision', 'uom.uom', 'pos.printer', 'pos_self_order.custom_link', 'restaurant.floor', 'restaurant.table', 'account.cash.rounding',
            'res.country', 'res.country.state', 'mail.template', 'pos.product.template.snooze']

    @api.model
    def _load_pos_self_data_domain(self, data, config):
        return [('id', '=', config.id)]

    @api.model
    def _load_pos_self_data_read(self, records, config):
        read_records = super()._load_pos_self_data_read(records, config)
        if not read_records:
            return read_records
        record = read_records[0]
        record['_self_ordering_image_home_ids'] = config.self_ordering_image_home_ids.ids
        record['_self_ordering_image_background_ids'] = config.self_ordering_image_background_ids.ids
        record['_pos_special_products_ids'] = config._get_special_products().ids
        record['_self_order_pos'] = True
        record['_base_url'] = config.get_base_url()
        return read_records

    def load_self_data(self):
        response = {}
        response['pos.config'] = self.env['pos.config']._load_pos_self_data_search_read(response, self)

        for model in self._load_self_data_models():
            try:
                response[model] = self.env[model]._load_pos_self_data_search_read(response, self)
            except AccessError:
                response[model] = []

        return response

    def load_data_params(self):
        response = {}
        fields = self._load_pos_self_data_fields(self)
        response['pos.config'] = {
            'fields': fields,
            'relations': self.env['pos.session']._load_pos_data_relations('pos.config', fields)
        }

        for model in self._load_self_data_models():
            fields = self.env[model]._load_pos_self_data_fields(self)
            response[model] = {
                'fields': fields,
                'relations': self.env['pos.session']._load_pos_data_relations(model, fields)
            }

        return response

    def _compute_self_ordering_url(self):
        for record in self:
            record.self_ordering_url = record.get_base_url() + record._get_self_order_route()

    def _can_use_cash_payment_method(self, cash_method):
        self.ensure_one()
        return self.self_ordering_mode == 'kiosk' or \
            not cash_method.config_ids.filtered(lambda config: config != self and config.self_ordering_mode != 'kiosk') or \
            super()._can_use_cash_payment_method(cash_method)

    def close_ui(self):
        if self.self_ordering_mode == "kiosk":
            return self.action_close_kiosk_session()
        return super().close_ui()

    def action_close_kiosk_session(self):
        if self.current_session_id and self.current_session_id.order_ids:
            self.current_session_id.order_ids.filtered(lambda o: o.state == 'draft').unlink()

        self._notify('STATUS', {'status': 'closed'})
        return self.current_session_id.action_pos_session_closing_control()

    def _compute_status(self):
        for record in self:
            record.status = 'active' if record.has_active_session else 'inactive'

    def action_open_wizard(self):
        self.ensure_one()

        if not self.current_session_id:
            res = self._check_before_creating_new_session()
            if res:
                return res
            session = self.env['pos.session'].create({'user_id': self.env.uid, 'config_id': self.id})
            session.set_opening_control(0, "")
            self._notify('STATUS', {'status': 'open'})

        return {
            'type': 'ir.actions.act_url',
            'name': _('Self Order'),
            'target': 'new',
            'url': self.get_kiosk_url(),
        }

    def get_kiosk_url(self):
        return self.self_ordering_url

    def has_valid_self_payment_method(self):
        """ Checks if the POS config has a valid payment method (terminal or online). """
        self.ensure_one()
        domain = self.payment_method_ids._load_pos_self_data_domain({}, self)
        return bool(self.payment_method_ids.filtered_domain(domain))

    @api.model
    def load_onboarding_kiosk_scenario(self):
        if not bool(self.env.company.chart_template):
            return

        journal, payment_methods_ids = self._create_journal_and_payment_methods()
        restaurant_categories = self.get_record_by_ref([
            'pos_restaurant.food',
            'pos_restaurant.drinks',
        ])
        not_cash_payment_methods_ids = self.env['pos.payment.method'].search([
            ('is_cash_count', '=', False),
            ('id', 'in', payment_methods_ids),
        ]).ids
        self.env['pos.config'].create({
            'name': _('Kiosk'),
            'company_id': self.env.company.id,
            'journal_id': journal.id,
            'payment_method_ids': not_cash_payment_methods_ids,
            'limit_categories': True,
            'iface_available_categ_ids': restaurant_categories,
            'iface_splitbill': True,
            'module_pos_restaurant': True,
            'self_ordering_mode': 'kiosk',
            'self_ordering_pay_after': 'each',
        })

    def _load_restaurant_demo_data(self, with_demo_data=True):
        self.ensure_one()
        super()._load_restaurant_demo_data(with_demo_data)
        if with_demo_data:
            self.self_ordering_mode = 'mobile'

    def _generate_single_qr_code__(self, url):  # noqa: PLW3201
        qr = qrcode.QRCode(
            version=1,
            error_correction=qrcode.constants.ERROR_CORRECT_L,
            box_size=10,
            border=4,
        )
        qr.add_data(url)
        qr.make(fit=True)
        return {
            'png': qr.make_image(fill_color="black", back_color="transparent"),
            'svg': qr.make_image(fill_color="black", back_color="transparent", image_factory=qrcode.image.svg.SvgImage),
        }

    def get_pos_qr_order_data(self):
        url_form = "https://www.odoo.com/app/point-of-sale-restaurant-qr-code"
        table_data = []
        if self.self_ordering_mode not in ['mobile', 'consultation']:
            return {
                'success': False,
                'error': 'INVALID_SELF_ORDERING_MODE',
            }

        table_ids = None
        if self.module_pos_restaurant:
            table_ids = self.floor_ids.table_ids

        if table_ids and self.self_ordering_mode == 'mobile':
            for table in table_ids:
                url = self._get_self_order_url(table.id)
                table_data.append({
                    'url': url,
                    'name': f"{table.floor_id.name} - {table.table_number}",
                })
        else:
            url = self._get_self_order_url()
            table_data.append({
                'url': url,
                'name': "generic",
            })

        zip_buffer = BytesIO()
        with zipfile.ZipFile(zip_buffer, "w", 0) as zip_file:
            for index, qr_data in enumerate(table_data, start=1):
                images = self._generate_single_qr_code__(unquote(qr_data['url']))
                with zip_file.open(f"{qr_data['name']} ({index}).png", "w") as buf:
                    images['png'].save(buf, format="PNG")
                with zip_file.open(f"{qr_data['name']} ({index}).svg", "w") as buf:
                    buf.write(images['svg'].to_string())
        zip_buffer.seek(0)

        return {
            'success': True,
            'table_data': table_data,
            'self_ordering_mode': self.self_ordering_mode,
            'db_name': self.env.cr.dbname,
            'redirect_url': url_form,
            'zip_archive': base64.b64encode(zip_buffer.read()).decode('utf-8'),
        }