import { ipcMain, BrowserWindow } from "electron";
import { getToken, saveToken, clearToken } from "../utils/tokenHelper.js";
import { getActiveApp, handleLogin, takeScreenshot, startWindowPolling, getRunningAppsList, captureSpecificApp } from "../utils/utilityFunctions.js";
import api from "../api/axiosClient.js";
import { getMainWindow } from '../main.js';
import { checkRegion } from "../api/regionCheck.js";
import { startVPN, stopVPN } from "../vpn.js";
import { getBaseURL, setBaseURL } from "../api/baseURL.js";




export const registerIPCHandlers = (mainWindow: BrowserWindow) => {
  console.log("⚙️ Registering IPC Handlers...");


  ipcMain.handle("GET_BASE_URL", () => {
    return getBaseURL();
  });

  // UPDATE Base URL
  ipcMain.handle("UPDATE_BASE_URL", (event, url: string) => {
    setBaseURL(url);
    api.defaults.baseURL = `${url}/api/v1/va`;
    console.log("Base URL updated to:", api.defaults.baseURL);
    return {
      updated: true,
      baseURL: url
    };
  });

  ipcMain.handle("get-token", async (_, key: "ACCESS_TOKEN" | "REFRESH_TOKEN") => {
    return await getToken(key);
  });

  ipcMain.handle("save-token", async (_, key: "ACCESS_TOKEN" | "REFRESH_TOKEN", token: string) => {
    await saveToken(key, token);
    return true;
  });

  ipcMain.handle("clear-token", async (_, key: string) => {
    await clearToken(key);
    return true;
  });

  ipcMain.handle("upload-screenshot", async () => {
    await takeScreenshot();
    return { success: true };
  });

  ipcMain.handle("login-request", async (_, credentials: { email: string; password: string }) => {
    return handleLogin(credentials);
  });

  ipcMain.handle("logout-request", async () => {
    try {
      console.log("Handle Logout listened");
      console.log("Token", await getToken("ACCESS_TOKEN"));
      const res = await api.get("/logout");
      if (res && "success" in res && res.success) {
        return { success: true, message: "Logout Successfully" };
      }
      return { success: false, message: "" };
    } catch {
      return { success: false, message: "Logout failed" };
    }
  });





  ipcMain.handle("get-active-app", async () => {
    return await getActiveApp();
  });

  ipcMain.handle('toggle-close-btn', (event, shouldEnable: boolean) => {
    const mainWindow = getMainWindow()
    console.log("toggle-close-btn Called", mainWindow)
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.setClosable(shouldEnable);
    }
  });



  ipcMain.handle("resize-window", (event, width: number, height: number) => {
    const mainWindow = getMainWindow();
    if (mainWindow && !mainWindow.isDestroyed()) {
      console.log(`📏 Resizing window to ${width}x${height}`);
      mainWindow.setResizable(true); // temporarily enable resizing
      mainWindow.setSize(width, height);
      mainWindow.setResizable(false); // disable again if you want to lock it
    }
  });


  // ✅ Start background polling when main window is ready
};
// startWindowPolling(mainWindow);



ipcMain.handle("get-project-list", async () => {
  console.log("📡 get-project-list called");
  try {
    const res = await api.get("/list/projects");

    console.log(" API /list/project response:", res);

    //  Return only serializable data
    return JSON.parse(JSON.stringify(res));
  } catch (error: any) {
    console.error(" get-project-list error:", error.status);
    return {
      success: false,
      message: error?.message || String(error) || "Unknown error",
      status: error?.status
    };
  }
});


// When project tracking start
ipcMain.handle("start-project-tracking", async (event, payload) => {
  try {
    console.log("🚀 start-project-tracking called with:", payload);

    const response = await api.post("/log/project", payload);

    console.log(" Tracking start synced:", response);
    return { success: true, data: response };
  } catch (error: any) {
    console.error("❌ Error syncing project start:", error);

    // If API sent a response (like 400)
    if (error.response) {
      return {
        success: false,
        message: error.response.data?.message || "Request failed",
        status: error.response.status
      };
    }

    return {
      success: false,
      message: "Something went wrong",
      status: 500
    };
  }
});



// When project tracking stop
ipcMain.handle("stop-project-tracking", async (event, payload) => {
  try {
    console.log("stop-project-tracking called with:", payload);

    const response = await api.post("/log/project", payload);

    console.log(" Tracking stop synced:", response);
    return response;
  } catch (error) {
    console.error(" Error syncing project stop:", error);
    throw error;
  }
});

// tabs opening and closing when and tracking start
ipcMain.handle("tracking-tabs-opening-and-closing", async (event, payload) => {
  try {
    console.log("🟦 IPC received payload:", payload);

    const response = await api.post("/log/project/track", payload);

    console.log("🟩 Log track API success:", response);

    return {
      success: true,
      data: response.data,
    };
  } catch (error) {
    console.error("❌ Log track API error:", error);

    return {
      success: false,
      message: "Something went wrong",
      error,
    };
  }
});




ipcMain.handle("get-project-logs", async (event, { projectID, fromDate, toDate }) => {
  try {
    console.log("📥 get-project-logs called with:", { projectID, fromDate, toDate });

    let url = `/report/project/${projectID}`;



    // 🧠 Append query params only if dates are provided
    if (fromDate && toDate) {
      const params = new URLSearchParams({
        from: fromDate,
        to: toDate,
      });
      url += `?${params.toString()}`;
    }

    console.log("url", url)

    const response = await api.get(url);
    console.log("✅ response-logs:", response);

    return { success: true, data: response.data };
  } catch (error) {
    console.error("❌ Error fetching project logs:", error);
    throw error;
  }
});

ipcMain.handle("forgot-password", async (event, email: string) => {
  try {
    const response = await api.post("/forgot-password", { email });
    console.log(response, "Line response")
    if (response) {
      return { success: true, message: response.data?.message };
    }
  } catch (error: any) {
    console.error("Forgot password error:", error.response?.data || error.message);
    return {
      success: false,
      message: error.response?.data?.message || "Something went wrong",
    };
  }
});

ipcMain.handle('get-running-apps', async () => {
  return await getRunningAppsList()
});

ipcMain.handle('capture-specific-window', async (event, appTitle: string) => {
  console.log(appTitle, "IPC HANDLE")
  return await captureSpecificApp(appTitle)
});

ipcMain.handle("get-profile", async () => {
  try {
    const response = await api.get("/profile");
    console.log(response.data)
    return {
      success: true,
      data: response.data,
    };
  } catch (error: any) {
    console.error(" Profile fetch error:", error.response?.data || error.message);
    return {
      success: false,
      message: error.response?.data?.message || "Something went wrong",
    };
  }
});

ipcMain.handle("change-password", async (event, data) => {
  console.log("data-change-password", data)


  // Build final payload
  const payload = {
    userDetails: {
      oldPassword: data.oldPassword,
      password: data.password,
      cPassword: data.cPassword,
    },
  };

  console.log("Change Password payload", payload)
  try {
    const response = await api.patch("/profile", payload);
    console.log("Chnage-passowrd-response", response)
    return { success: true, data: response.data };
  } catch (error: any) {
    console.error("❌ Change password error:", error.message);
    return {
      success: false,
      message: error.response?.data?.message || "Password update failed",
    };
  }
});

ipcMain.handle("get-project-summary", async (_, { projectId, date }) => {
  try {
    const url = `/timesheet/summary/${projectId}/${date}`;
    console.log("📡 Fetching summary:", url);

    const res = await api.get(url);
    return {
      success: true,
      data: res.data,
    };
  } catch (error: any) {
    console.error("❌ Error fetching summary:", error.message);
    return {
      success: false,
      message: error.response?.data?.message || "Something went wrong",
    };
  }
});

ipcMain.handle("create-timesheet", async (event, data) => {

  console.log("data", data)
  try {
    console.log("📩 Timesheet Payload:", data);

    const res = await api.post("/timesheet/adjustment/request", data);

    console.log(res, " Line 323")

    return {
      success: true,
      message: "Timesheet created successfully",
      data: res,
    };
  } catch (error: any) {
    console.error("❌ Timesheet Error:", error);

    return {
      success: false,
      message: error.response?.data?.message || "Failed to create timesheet",
    };
  }
})


ipcMain.handle("create-leave-request", async (event, payload) => {
  try {
    console.log("Leave Request Received:", payload);

    const response = await api.post("/leave/request", payload);

    console.log("Leave Saved:", response);

    return {
      success: true,
      data: response.data
    };

  } catch (error: any) {
    console.error("❌ Leave Save Failed:");

    let message = "Unknown error";

    console.log(error.response)

    if (error.response) {
      console.log("Status:", error.response.status);
      console.log("Message:", error.response.statusText);
      console.log("Server Response:", error.response.data);

      // Extract the backend message properly
      message = error.response.data?.message || error.response.statusText;
    } else {
      message = error.message;
    }

    return {
      success: false,
      message
    };
  }
});



ipcMain.handle("get-schedules", async () => {
  try {
    console.log(" Fetching schedules...");

    const response = await api.get("/payrollSchedule"); // Backend API call

    console.log("✅ Schedule Data:", response.data);

    return {
      success: true,
      result: response.data
    };

  } catch (error: any) {
    console.error("❌ Fetch Schedules Failed:");

    let message = "Unknown error occurred";

    if (error.response) {
      console.log("Status:", error.response.status);
      console.log("Message:", error.response.statusText);
      console.log("Server Response:", error.response.data);

      message = error.response.data?.message || error.response.statusText;
    } else {
      message = error.message;
    }

    return {
      success: false,
      message
    };
  }
});


ipcMain.handle("get-payslips", async (event, vaId: string) => {
  console.log("get-payslips", vaId)
  try {
    const response = await api.get(`/paySlip/${vaId}`);
    console.log(response.data, "Line 409")
    return {
      success: true,
      data: response.data || [],
    };
  } catch (error: any) {
    let message = "Unknown error occurred";

    if (error.response) {
      console.log("Status:", error.response.status);
      console.log("Message:", error.response.statusText);
      console.log("Server Response:", error.response.data);

      message = error.response.data?.message || error.response.statusText;
    } else {
      message = error.message;
    }

    return {
      success: false,
      message
    };
  }
});



ipcMain.handle("get-leave-list", async () => {

  try {
    const res = await api.get("/leaves/all");

    console.log("/leaves/all", res.data);
    return {
      success: true,
      data: res.data,
    };
  } catch (error: any) {
    let message = "Unknown error occurred";

    if (error.response) {
      console.log("Status:", error.response.status);
      console.log("Message:", error.response.statusText);
      console.log("Server Response:", error.response.data);

      message = error.response.data?.message || error.response.statusText;
    } else {
      message = error.message;
    }
    return {
      success: false,
      message
    };
  }
});

ipcMain.handle("get-adjustments-list", async (event, vaId: string) => {

  try {
    const res = await api.get(`/timesheet/adjustments/list?vaId=${vaId}`);

    console.log("/timesheet/adjustments/list", res.data);
    return {
      success: true,
      data: res.data,
    };
  } catch (error: any) {
    let message = "Unknown error occurred";

    if (error.response) {
      console.log("Status:", error.response.status);
      console.log("Message:", error.response.statusText);
      console.log("Server Response:", error.response.data);

      message = error.response.data?.message || error.response.statusText;
    } else {
      message = error.message;
    }
    return {
      success: false,
      message
    };
  }
});


ipcMain.handle("update-payment", async (event, data: Record<string, any>) => {
  console.log("data-update-payment", data);

  // Build userDetails object
  const userDetails: Record<string, any> = {
    paymentMethod: data.paymentMethod,
  };

  // Add payment-specific fields
  if (data.paymentMethod === "wise" && data.wiseEmail) {
    userDetails.wiseEmail = data.wiseEmail;
    // Clear veemAccount when switching to wise
    userDetails.veemAccount = "";
  } else if (data.paymentMethod === "veem" && data.veemAccount) {
    userDetails.veemAccount = data.veemAccount;
    // Clear wiseEmail when switching to veem
    userDetails.wiseEmail = "";
  }

  // Build final payload
  const payload = {
    userDetails: userDetails,
  };

  console.log("Update Payment payload", payload);

  try {
    const response = await api.patch("/profile", payload);
    console.log("Update-payment-response", response);
    return { success: true, data: response?.data?.userDetails };
  } catch (error: any) {
    console.error("❌ Update payment error:", error.message);
    return {
      success: false,
      message: error.response?.data?.message || "Payment update failed",
    };
  }
});



ipcMain.handle("check-region", async () => {
  return await checkRegion();
});



export const sendTokenExpired = () => {
  console.log("⚠️ Sending token-expired event to renderer");

  BrowserWindow.getAllWindows().forEach((win) => {
    if (!win.isDestroyed()) {
      win.webContents.send("token-expired");
    }
  });
};


ipcMain.handle("vpn-connect", async () => {
  return startVPN();
});

ipcMain.handle("vpn-disconnect", async () => {
  stopVPN();
});