# © 2016 Daniel Reis
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).

import logging
from ast import literal_eval

from lxml import etree

from odoo import _, api, fields, models, tools
from odoo.exceptions import ValidationError

_logger = logging.getLogger(__name__)
# Extended name search is only used on some operators
ALLOWED_OPS = {"ilike", "like"}


@tools.ormcache(skiparg=0)
def _get_rec_names(self):
    "List of fields to search into"
    model = self.env["ir.model"].search([("model", "=", str(self._name))])
    rec_name = [self._rec_name] or []
    other_names = model.name_search_ids.mapped("name")
    return rec_name + other_names


@tools.ormcache(skiparg=0)
def _get_use_smart_name_search(self):
    return self.env['ir.model'].search([('model', '=', str(self._name))]).use_smart_name_search


@tools.ormcache(skiparg=0)
def _get_add_smart_search(self):
    "Add Smart Search on search views"
    model = self.env["ir.model"].search([("model", "=", str(self._name))])
    # Run only if module is installed
    if hasattr(model, "add_smart_search"):
        return model.add_smart_search
    return False


@tools.ormcache(skiparg=0)
def _get_name_search_domain(self):
    "Add Smart Search on search views"
    name_search_domain = (
        self.env["ir.model"]
        .search([("model", "=", str(self._name))])
        .name_search_domain
    )
    if name_search_domain:
        return literal_eval(name_search_domain)
    return []


def _extend_name_results(self, domain, results, limit, name_get_uid):
    result_count = len(results)
    if result_count < limit:
        domain += [("id", "not in", [x[0] for x in results])]
        rec_ids = self._search(domain, limit=limit - result_count, access_rights_uid=name_get_uid)
        results.extend(models.lazy_name_get(self.browse(rec_ids).with_user(name_get_uid)))
    return results


def patch_name_search():
    @api.model
    def _name_search(self, name='', args=None, operator='ilike', limit=100, name_get_uid=None):
        # Perform standard name search
        res = _name_search.origin(
            self, name=name, args=args, operator=operator, limit=limit, name_get_uid=name_get_uid
        )
        if name and _get_use_smart_name_search(self) and operator in ALLOWED_OPS:
            limit = limit or 0
            superself = self.sudo()

            # we add domain
            args = args or [] + _get_name_search_domain(superself)

            # Support a list of fields to search on
            all_names = _get_rec_names(superself)
            base_domain = args or []
            # Try regular search on each additional search field
            for rec_name in all_names[1:]:
                domain = [(rec_name, operator, name)]
                res = _extend_name_results(self, base_domain + domain, res, limit, name_get_uid)
            # Try ordered word search on each of the search fields
            for rec_name in all_names:
                domain = [(rec_name, operator, name.replace(" ", "%"))]
                res = _extend_name_results(self, base_domain + domain, res, limit, name_get_uid)
            # Try unordered word search on each of the search fields
            # we only perform this search if we have at least one
            # separator character
            # also, if have raise the limit we skeep this iteration
            if " " in name and len(res) < limit:
                domain = []
                for word in name.split():
                    word_domain = []
                    for rec_name in all_names:
                        word_domain = (
                            word_domain and ["|"] + word_domain or word_domain
                        ) + [(rec_name, operator, word)]
                    domain = (domain and ["&"] + domain or domain) + word_domain
                res = _extend_name_results(self, base_domain + domain, res, limit, name_get_uid)

        return res

    return _name_search


def patch_fields_view_get():
    @api.model
    def fields_view_get(
        self, view_id=None, view_type="form", toolbar=False, submenu=False
    ):
        res = fields_view_get.origin(
            self,
            view_id=view_id,
            view_type=view_type,
            toolbar=toolbar,
            submenu=submenu,
        )
        if view_type == "search" and _get_add_smart_search(self):
            eview = etree.fromstring(res["arch"])
            placeholders = eview.xpath("//search/field")
            if placeholders:
                placeholder = placeholders[0]
            else:
                placeholder = eview.xpath("//search")[0]
            placeholder.addnext(etree.Element("field", {"name": "smart_search"}))
            eview.remove(placeholder)
            res["arch"] = etree.tostring(eview)
            res["fields"].update(self.fields_get(["smart_search"]))
        return res

    return fields_view_get


class Base(models.AbstractModel):

    _inherit = "base"

    # TODO perhaps better to create only the field when enabled on the model
    smart_search = fields.Char(
        compute="_compute_smart_search",
        search="_search_smart_search",
    )

    def _compute_smart_search(self):
        self.smart_search = False

    @api.model
    def _search_smart_search(self, operator, value):
        """
        Por ahora este método no llama a
        self._name_search(name, operator=operator) ya que este no es tan
        performante si se llama a ilimitados registros que es lo que el
        name search debe devolver. Por eso se reimplementa acá nuevamente.
        Además name_search tiene una lógica por la cual trata de devolver
        primero los que mejor coinciden, en este caso eso no es necesario
        Igualmente seguro se puede mejorar y unificar bastante código
        """
        name = value
        if name and operator in ALLOWED_OPS:
            superself = self.sudo()
            all_names = _get_rec_names(superself)
            domain = _get_name_search_domain(superself)
            for word in name.split():
                word_domain = []
                for rec_name in all_names:
                    word_domain = (
                        word_domain and ["|"] + word_domain or word_domain
                    ) + [(rec_name, operator, word)]
                domain = (domain and ["&"] + domain or domain) + word_domain
            return domain
        return []


class IrModel(models.Model):
    _inherit = "ir.model"

    add_smart_search = fields.Boolean(help="Add Smart Search on search views",)
    use_smart_name_search = fields.Boolean(
        string='Smart Name Search Enabled?', help="Use Smart Search for 'name_search', this will affect when searching"
        "from other records (for eg. from m2o fields")
    name_search_ids = fields.Many2many("ir.model.fields", string="Smart Search Fields")
    name_search_domain = fields.Char(string='Smart Search Domain')
    smart_search_warning = fields.Html(compute='_smart_search_warning')

    @api.depends('name_search_ids')
    def _smart_search_warning(self):
        msgs = []
        for rec in self:
            if len(rec.name_search_ids) > 4:
                msgs.append(
                    'Ha seleccionado más de 4 campos para smart search, recomendamos que intente utilizar menos '
                    'campos')
            if any(x.translate for x in rec.name_search_ids):
                msgs.append(
                    'Ha seleccionado campos traducibles en la búsqueda inteligente, de ser posible intente '
                    'evitar los mismos')
            # rec.smart_search_warning = msg
            if msgs:
                rec.smart_search_warning = (
                    '<p>Si tiene problemas de performance en las búsquedas le recomendamos revisar estas '
                    'sugerencias: <ul>%s</ul></p>') % "".join(["<li>%s</li>" % x for x in msgs])
            else:
                rec.smart_search_warning = False

    @api.constrains("name_search_ids", "name_search_domain", "add_smart_search")
    def update_search_wo_restart(self):
        self.clear_caches()

    @api.constrains("name_search_domain")
    def check_name_search_domain(self):
        for rec in self.filtered("name_search_domain"):
            name_search_domain = False
            try:
                name_search_domain = literal_eval(rec.name_search_domain)
            except Exception as error:
                raise ValidationError(
                    _("Couldn't eval Name Search Domain (%s)") % error
                )
            if not isinstance(name_search_domain, list):
                raise ValidationError(_("Name Search Domain must be a list of tuples"))

    def _register_hook(self):

        _logger.info("Patching BaseModel for Smart Search")
        models.BaseModel._patch_method("fields_view_get", patch_fields_view_get())

        for model in self.sudo().search(self.ids or []):
            Model = self.env.get(model.model)
            if Model is not None:
                Model._patch_method("_name_search", patch_name_search())

        return super(IrModel, self)._register_hook()