use clippy_utils::diagnostics::span_lint;
use rustc_hir::{Expr, ExprKind};
use rustc_lint::{LateContext, LateLintPass};

use crate::render_helpers::{
    is_directly_in_render_method, is_gpui_entity_or_weak, is_unit_or_result_unit,
};

rustc_session::declare_lint! {
    /// ### What it does
    ///
    /// Flags calls to `Entity::update` or `WeakEntity::update` that execute
    /// synchronously inside a `Render::render` or `RenderOnce::render` method
    /// and whose closure returns `()` (indicating mutation rather than reading).
    ///
    /// ### Why is this bad?
    ///
    /// The `render` method should be a pure function of state. Calling
    /// `.update()` mutates an entity during the render pass, which can trigger
    /// re-renders mid-render and lead to inconsistent UI state or infinite
    /// render loops.
    pub ENTITY_UPDATE_IN_RENDER,
    Warn,
    "mutating an entity via `.update()` during render"
}

pub(crate) struct EntityUpdateInRender;

rustc_session::impl_lint_pass!(EntityUpdateInRender => [ENTITY_UPDATE_IN_RENDER]);

impl<'tcx> LateLintPass<'tcx> for EntityUpdateInRender {
    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
        if expr.span.from_expansion() {
            return;
        }

        let ExprKind::MethodCall(segment, receiver, _args, _span) = &expr.kind else {
            return;
        };

        if segment.ident.name.as_str() != "update" {
            return;
        }

        let receiver_ty = cx.typeck_results().expr_ty(receiver);
        if !is_gpui_entity_or_weak(cx, receiver_ty) {
            return;
        }

        let call_ty = cx.typeck_results().expr_ty(expr);
        if !is_unit_or_result_unit(cx, call_ty) {
            return;
        }

        if !is_directly_in_render_method(cx, expr.hir_id) {
            return;
        }

        span_lint(
            cx,
            ENTITY_UPDATE_IN_RENDER,
            expr.span,
            "entity `.update()` called during render mutates state in the render pass",
        );
    }
}