-module(logic_moderation_tests).
-include_lib("eunit/include/eunit.hrl").
-include("records.hrl").

setup() ->
  mnesia:start(),
  mnesia:create_table(user, [{attributes, record_info(fields, user)}, {ram_copies, [node()]}]),
  mnesia:create_table(calendar, [{attributes, record_info(fields, calendar)}, {ram_copies, [node()]}]),
  mnesia:create_table(event, [{attributes, record_info(fields, event)}, {ram_copies, [node()]}]),
  mnesia:create_table(report, [{attributes, record_info(fields, report)}, {ram_copies, [node()]}]),
  mnesia:create_table(banned_word, [{attributes, record_info(fields, banned_word)}, {ram_copies, [node()]}]),
  ok.

cleanup(_) ->
  mnesia:delete_table(banned_word),
  mnesia:delete_table(report),
  mnesia:delete_table(event),
  mnesia:delete_table(calendar),
  mnesia:delete_table(user),
  mnesia:stop(),
  ok.

logic_moderation_test_() ->
  {foreach,
    fun setup/0,
    fun cleanup/1,
    [
      {"Create report test", fun test_create_report/0},
      {"Get reports test", fun test_get_reports/0},
      {"Resolve report test", fun test_resolve_report/0},
      {"Add banned word test", fun test_add_banned_word/0},
      {"Remove banned word test", fun test_remove_banned_word/0},
      {"Auto freeze by reports test", fun test_auto_freeze/0},
      {"Freeze/unfreeze calendar test", fun test_freeze_calendar/0},
      {"Freeze/unfreeze event test", fun test_freeze_event/0},
      {"Check content test", fun test_check_content/0}
    ]}.

create_test_user(Role) ->
  UserId = base64:encode(crypto:strong_rand_bytes(16), #{mode => urlsafe, padding => false}),
  User = #user{id = UserId, email = <<UserId/binary, "@test.com">>, password_hash = <<"hash">>,
    role = Role, status = active, created_at = calendar:universal_time(), updated_at = calendar:universal_time()},
  mnesia:dirty_write(User),
  UserId.

create_test_calendar(OwnerId) ->
  {ok, Calendar} = core_calendar:create(OwnerId, <<"Test">>, <<"">>, manual),
  Calendar#calendar.id.

create_test_event(CalendarId) ->
  {ok, Event} = core_event:create(CalendarId, <<"Event">>, {{2026, 6, 1}, {10, 0, 0}}, 60),
  Event#event.id.

test_create_report() ->
  ReporterId = create_test_user(user),
  OwnerId = create_test_user(user),
  CalendarId = create_test_calendar(OwnerId),
  EventId = create_test_event(CalendarId),

  {ok, Report} = logic_moderation:create_report(ReporterId, event, EventId, <<"Bad content">>),
  ?assertEqual(ReporterId, Report#report.reporter_id),
  ?assertEqual(pending, Report#report.status).

test_get_reports() ->
  AdminId = create_test_user(admin),
  ReporterId = create_test_user(user),
  OwnerId = create_test_user(user),
  CalendarId = create_test_calendar(OwnerId),
  EventId = create_test_event(CalendarId),

  {ok, _} = logic_moderation:create_report(ReporterId, event, EventId, <<"">>),

  {ok, Reports} = logic_moderation:get_reports(AdminId),
  ?assertEqual(1, length(Reports)).

test_resolve_report() ->
  AdminId = create_test_user(admin),
  ReporterId = create_test_user(user),
  OwnerId = create_test_user(user),
  CalendarId = create_test_calendar(OwnerId),
  EventId = create_test_event(CalendarId),

  {ok, Report} = logic_moderation:create_report(ReporterId, event, EventId, <<"">>),
  {ok, Resolved} = logic_moderation:resolve_report(AdminId, Report#report.id, reviewed),
  ?assertEqual(reviewed, Resolved#report.status),
  ?assertEqual(AdminId, Resolved#report.resolved_by).

test_add_banned_word() ->
  AdminId = create_test_user(admin),
  {ok, _} = logic_moderation:add_banned_word(AdminId, <<"badword">>),
  ?assert(core_banned_word:is_banned(<<"badword">>)).

test_remove_banned_word() ->
  AdminId = create_test_user(admin),
  {ok, _} = logic_moderation:add_banned_word(AdminId, <<"badword">>),
  {ok, removed} = logic_moderation:remove_banned_word(AdminId, <<"badword">>),
  ?assertNot(core_banned_word:is_banned(<<"badword">>)).

test_auto_freeze() ->
  Reporter1 = create_test_user(user),
  Reporter2 = create_test_user(user),
  Reporter3 = create_test_user(user),
  OwnerId = create_test_user(user),
  CalendarId = create_test_calendar(OwnerId),
  EventId = create_test_event(CalendarId),

  % 3 жалобы должны заморозить событие
  {ok, _} = logic_moderation:create_report(Reporter1, event, EventId, <<"">>),
  {ok, _} = logic_moderation:create_report(Reporter2, event, EventId, <<"">>),
  {ok, _} = logic_moderation:create_report(Reporter3, event, EventId, <<"">>),

  {ok, Event} = core_event:get_by_id(EventId),
  ?assertEqual(frozen, Event#event.status).

test_freeze_calendar() ->
  AdminId = create_test_user(admin),
  OwnerId = create_test_user(user),
  CalendarId = create_test_calendar(OwnerId),

  {ok, Frozen} = logic_moderation:freeze_calendar(AdminId, CalendarId),
  ?assertEqual(frozen, Frozen#calendar.status),

  {ok, Unfrozen} = logic_moderation:unfreeze_calendar(AdminId, CalendarId),
  ?assertEqual(active, Unfrozen#calendar.status).

test_freeze_event() ->
  AdminId = create_test_user(admin),
  OwnerId = create_test_user(user),
  CalendarId = create_test_calendar(OwnerId),
  EventId = create_test_event(CalendarId),

  {ok, Frozen} = logic_moderation:freeze_event(AdminId, EventId),
  ?assertEqual(frozen, Frozen#event.status),

  {ok, Unfrozen} = logic_moderation:unfreeze_event(AdminId, EventId),
  ?assertEqual(active, Unfrozen#event.status).

test_check_content() ->
  AdminId = create_test_user(admin),
  {ok, _} = logic_moderation:add_banned_word(AdminId, <<"bad">>),

  ?assertNot(logic_moderation:check_content(<<"Hello">>)),
  ?assert(logic_moderation:check_content(<<"This is bad">>)),

  ?assertEqual(<<"Hello">>, logic_moderation:auto_moderate(<<"Hello">>)),
  ?assertEqual(<<"This is ***">>, logic_moderation:auto_moderate(<<"This is bad">>)).