import type { Context } from "hono";
import { AdminActivityLogRepository } from "@/internal/admin-activity-logs/admin-activity-logs.repository";
import { success, error } from "@/lib/response";

export const AdminActivityLogController = (ctx: Context) => {
  const db = ctx.get("datastore");
  const repo = AdminActivityLogRepository(db);

  return {
    async SearchLogs() {
      try {
        const queries = ctx.req.queries();
        const query = ctx.req.query();
        
        const limit = query.limit ? parseInt(query.limit) : 50;
        const offset = query.offset ? parseInt(query.offset) : 0;
        const search = query.search;
        const from_date = query.from_date;
        const to_date = query.to_date;
        const entity_id = query.entity_id;

        const result = await repo.searchLogs({
          admin_email: queries.admin_email,
          log_category: queries.log_category,
          method: queries.method,
          status_group: queries.status_group,
          from_date,
          to_date,
          entity_id,
          search,
          limit,
          offset,
        });

        return success(ctx, result, "Activity logs fetched successfully");
      } catch (err: any) {
        return error(ctx, `Failed to search logs: ${err.message}`, 500);
      }
    },

    async WriteLog() {
      try {
        const payload = await ctx.req.json();
        const adminEmail = ctx.get("adminEmail") || "anonymous";
        const userAgent = ctx.req.header("user-agent");
        const ipAddress = ctx.req.header("x-forwarded-for") || ctx.req.header("remote-addr");

        await repo.insertLog({
          admin_email: adminEmail,
          action: payload.action || "Client Action",
          method: payload.method || "UI",
          url: payload.url || ctx.req.url,
          status_code: payload.status_code || 200,
          log_category: payload.log_category || "UI",
          metadata: payload.metadata || null,
          ip_address: ipAddress || null,
          user_agent: userAgent || null,
          performed_at: new Date(),
        });

        return success(ctx, null, "Log recorded successfully");
      } catch (err: any) {
        return error(ctx, `Failed to write log: ${err.message}`, 500);
      }
    },

    async ClearAllLogs() {
      try {
        const body = await ctx.req.json().catch(() => ({}));
        const ids = body.ids;
        await repo.deleteAllLogs(ids);
        return success(ctx, null, ids?.length ? `${ids.length} activity logs cleared successfully` : "All activity logs cleared successfully");
      } catch (err: any) {
        return error(ctx, `Failed to clear logs: ${err.message}`, 500);
      }
    },
  };
};