import ApplicationService from "../../../services/ApplicationService";

export const getDataCenters = () => {
  return async (dispatch) => {
    dispatch({
      type: "GET_DATA_CENTERS_LOADING",
    });

    // Get access token
    const accessToken = localStorage.getItem("accessToken");
    if (!accessToken) {
      dispatch({
        type: "GET_DATA_CENTERS_ERROR",
        payload: {
          error: "No access token found. Please log in again.",
        },
      });
      return;
    }

    ApplicationService.http()
      .post(
        "/graphql",
        {
          query: `
            query GetDataCenters {
              dataCenters(sortBy: [{ direction: DESC, field: "number" }]) {
                id
                dataCenter
                externalId
                ayposURL
                number
                address
                latitude
                longitude
                area {
                  tag
                  cityNames
                  districtNames
                }
                projects {
                  id
                  name
                  physicalMachines {
                    id
                    name
                    vms {
                      active {
                        id
                        status
                        name
                        power
                        config {
                          id
                          cpu
                          ram
                          disk
                        }
                      }
                    }
                  }
                }
              }
            }
          `,
        },
        {
          headers: {
            Authorization: "Bearer " + accessToken,
            "Content-Type": "application/json",
          },
        }
      )
      .then((response) => {
        // Debug logging
        console.log("GraphQL Response:", {
          status: response.status,
          data: response.data,
          errors: response.data?.errors
        });

        // Check for GraphQL errors
        if (response.data?.errors) {
          throw new Error(response.data.errors[0].message);
        }

        // Validate response structure
        if (!response.data?.data?.dataCenters) {
          throw new Error("Invalid response structure: dataCenters not found");
        }

        const dataCenters = response.data.data.dataCenters;
        
        // Validate dataCenters is an array
        if (!Array.isArray(dataCenters)) {
          throw new Error("Invalid response: dataCenters is not an array");
        }

        dispatch({
          type: "GET_DATA_CENTERS_SUCCESS",
          payload: {
            dataCenters,
          },
        });
      })
      .catch((error) => {
        // Enhanced error logging
        console.error("Error fetching data centers:", {
          message: error.message,
          response: error.response?.data,
          status: error.response?.status,
          stack: error.stack
        });

        // Check for specific error types
        let errorMessage = "Failed to fetch data centers";
        if (error.response?.status === 401) {
          errorMessage = "Unauthorized. Please log in again.";
        } else if (error.response?.status === 403) {
          errorMessage = "You don't have permission to view data centers.";
        } else if (error.message) {
          errorMessage = error.message;
        }

        dispatch({
          type: "GET_DATA_CENTERS_ERROR",
          payload: {
            error: errorMessage,
          },
        });
      });
  };
};

export const createDataCenter = (dataCenterData) => {
  return async (dispatch) => {
    dispatch({
      type: "CREATE_DATA_CENTER_LOADING",
    });

    try {
      const response = await ApplicationService.http().post(
        "/graphql",
        {
          query: `
            mutation CreateDataCenter($input: DataCenterInput!) {
              createDataCenter(input: $input) {
                id
                dataCenter
                externalId
                ayposURL
                number
                address
                latitude
                longitude
                area {
                  tag
                  cityNames
                  districtNames
                }
              }
            }
          `,
          variables: {
            input: {
              dataCenter: dataCenterData.name,
              externalId: parseInt(dataCenterData.externalId),
              ayposURL: dataCenterData.ayposURL || "",
              number: parseInt(dataCenterData.number) || 1,
              areaId: dataCenterData.areaId,
              address: dataCenterData.address || "",
              latitude: dataCenterData.latitude ? parseFloat(dataCenterData.latitude) : null,
              longitude: dataCenterData.longitude ? parseFloat(dataCenterData.longitude) : null,
              city: dataCenterData.city
            }
          }
        },
        {
          headers: {
            Authorization: "Bearer " + localStorage.getItem("accessToken"),
          },
        }
      );

      // Debug logging
      console.log("Create Response:", {
        status: response.status,
        data: response.data,
        errors: response.data?.errors
      });

      if (response.data?.errors) {
        throw new Error(response.data.errors[0].message);
      }

      if (!response.data?.data?.createDataCenter) {
        throw new Error("Invalid response: createDataCenter data not found");
      }

      dispatch({
        type: "CREATE_DATA_CENTER_SUCCESS",
        payload: response.data.data.createDataCenter,
      });

      return response.data.data.createDataCenter;
    } catch (error) {
      console.error("Error creating data center:", error);
      dispatch({
        type: "CREATE_DATA_CENTER_ERROR",
        payload: {
          error: error.message || "Failed to create data center",
        },
      });
      throw error;
    }
  };
};

export const updateDataCenter = (id, dataCenterData) => {
  return async (dispatch) => {
    dispatch({
      type: "UPDATE_DATA_CENTER_LOADING",
    });

    try {
      const response = await ApplicationService.http().post(
        "/graphql",
        {
          query: `
            mutation UpdateDataCenter($id: ID!, $input: DataCenterInput!) {
              updateDataCenter(id: $id, input: $input) {
                id
                dataCenter
                externalId
                ayposURL
                number
                address
                latitude
                longitude
                area {
                  tag
                  cityNames
                  districtNames
                }
              }
            }
          `,
          variables: {
            id: id,
            input: {
              dataCenter: dataCenterData.name,
              externalId: parseInt(dataCenterData.externalId),
              ayposURL: dataCenterData.ayposURL || "",
              number: parseInt(dataCenterData.number) || 1,
              areaId: dataCenterData.areaId,
              address: dataCenterData.address || "",
              latitude: dataCenterData.latitude ? parseFloat(dataCenterData.latitude) : null,
              longitude: dataCenterData.longitude ? parseFloat(dataCenterData.longitude) : null,
              city: dataCenterData.city
            }
          }
        },
        {
          headers: {
            Authorization: "Bearer " + localStorage.getItem("accessToken"),
          },
        }
      );

      if (response.data?.errors) {
        throw new Error(response.data.errors[0].message);
      }

      dispatch({
        type: "UPDATE_DATA_CENTER_SUCCESS",
        payload: response.data.data.updateDataCenter
      });

      return response.data.data.updateDataCenter;
    } catch (error) {
      console.error("Error updating data center:", error);
      dispatch({
        type: "UPDATE_DATA_CENTER_ERROR",
        payload: {
          error: error.message || "Failed to update data center",
        },
      });
      throw error;
    }
  };
};

export const deleteDataCenter = (id) => {
  return async (dispatch) => {
    dispatch({
      type: "DELETE_DATA_CENTER_LOADING",
    });

    try {
      const response = await ApplicationService.http().post(
        "/graphql",
        {
          query: `
            mutation DeleteDataCenter($id: ID!) {
              deleteDataCenter(id: $id)
            }
          `,
          variables: {
            id: id
          }
        },
        {
          headers: {
            Authorization: "Bearer " + localStorage.getItem("accessToken"),
          },
        }
      );

      if (response.data?.errors) {
        throw new Error(response.data.errors[0].message);
      }

      dispatch({
        type: "DELETE_DATA_CENTER_SUCCESS",
        payload: id
      });

      return true;
    } catch (error) {
      console.error("Error deleting data center:", error);
      dispatch({
        type: "DELETE_DATA_CENTER_ERROR",
        payload: {
          error: error.message || "Failed to delete data center",
        },
      });
      throw error;
    }
  };
};

export const getDataCenterVMs = (dataCenterId) => {
  return new Promise(async (resolve, reject) => {
    // Don't make the request if dataCenterId is undefined, null, or empty
    if (!dataCenterId || dataCenterId === "undefined") {
      console.log('getDataCenterVMs: No dataCenterId provided');
      resolve([]);
      return;
    }

    try {
      console.log('getDataCenterVMs: Fetching VMs for data center:', dataCenterId);
      const response = await ApplicationService.http()
        .post(
          "/graphql",
          {
            query: `
            {
                dataCenter(id: "${dataCenterId}") {
                  id
                  dataCenter
                  projects {
                    id
                    name
                    physicalMachines {
                      id
                      name
                      vms {
                        active {
                          id
                          name
                          status
                          power
                        }
                        inactive {
                          id
                          name
                          status
                          power
                        }
                      }
                    }
                  }
                }
              }
             `,
          },
          {
            headers: {
              Authorization: "Bearer " + localStorage.getItem("accessToken"),
            },
          }
        );

      const dataCenter = response?.data?.data?.dataCenter;
      console.log('getDataCenterVMs: Data center response:', dataCenter);
      
      let allVMs = [];
      
      if (dataCenter && dataCenter.projects) {
        dataCenter.projects.forEach(project => {
          if (project.physicalMachines) {
            project.physicalMachines.forEach(pm => {
              if (pm.vms) {
                if (pm.vms.active) {
                  allVMs = allVMs.concat(pm.vms.active);
                }
                if (pm.vms.inactive) {
                  allVMs = allVMs.concat(pm.vms.inactive);
                }
              }
            });
          }
        });
      }
      
      console.log('getDataCenterVMs: Found VMs:', allVMs);
      resolve(allVMs);
    } catch (error) {
      console.error("Error fetching VMs by data center:", error);
      resolve([]);
    }
  });
};