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 {
                  id
                  tag
                  cities {
                    id
                    name
                  }
                  districts {
                    id
                    name
                  }
                }
                city {
                  id
                  name
                }
                emissionScope {
                  id
                  tag
                  description
                }
                sector {
                  id
                  tag
                }
                subSector {
                  id
                  tag
                }
                dataCenterEmissionSources {
                  id
                  emissionSource {
                    id
                    tag
                  }
                  consuptionUnit {
                    id
                    description
                  }
                  isDefault
                  percentage
                }
                activitySubUnit {
                  id
                  tag
                }
                physicalMachines {
                  id
                  name
                  vms {
                    id
                    vmName
                    state
                    power
                    calcOn
                    hostingPm
                    host
                    flavorName
                    tag
                    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: DataCenterCreateInput!) {
              createDataCenter(input: $input) {
                id
                dataCenter
                externalId
                ayposURL
                number
                address
                latitude
                longitude
                area {
                  id
                  tag
                  cities {
                    id
                    name
                  }
                  districts {
                    id
                    name
                  }
                }
                city {
                  id
                  name
                }
                emissionScope {
                  id
                  tag
                  description
                }
                sector {
                  id
                  tag
                }
                subSector {
                  id
                  tag
                }
                dataCenterEmissionSources {
                  id
                  emissionSource {
                    id
                    tag
                  }
                  consuptionUnit {
                    id
                    description
                  }
                  isDefault
                  percentage
                }
                activitySubUnit {
                  id
                  tag
                }
              }
            }
          `,
          variables: {
            input: {
              dataCenter: dataCenterData.name,
              externalId: parseInt(dataCenterData.externalId),
              ayposURL: dataCenterData.ayposURL || "",
              number: parseInt(dataCenterData.number) || 1,
              areaId: dataCenterData.areaId || null,
              cityId: dataCenterData.cityId || null,
              address: dataCenterData.address || "",
              latitude: dataCenterData.latitude
                ? parseFloat(dataCenterData.latitude)
                : null,
              longitude: dataCenterData.longitude
                ? parseFloat(dataCenterData.longitude)
                : null,
              emissionScopeId: dataCenterData.emissionScopeId || null,
              sectorId: dataCenterData.sectorId || null,
              subSectorId: dataCenterData.subSectorId || null,
              dataCenterEmissionSources:
                dataCenterData.dataCenterEmissionSources || [],
              activitySubUnitId: dataCenterData.activitySubUnitId || null,
            },
          },
        },
        {
          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: DataCenterUpdateInput!) {
              updateDataCenter(id: $id, input: $input) {
                id
                dataCenter
                externalId
                ayposURL
                number
                address
                latitude
                longitude
                area {
                  id
                  tag
                  cities {
                    id
                    name
                  }
                  districts {
                    id
                    name
                  }
                }
                city {
                  id
                  name
                }
                emissionScope {
                  id
                  tag
                  description
                }
                sector {
                  id
                  tag
                }
                subSector {
                  id
                  tag
                }
                dataCenterEmissionSources {
                  id
                  emissionSource {
                    id
                    tag
                  }
                  consuptionUnit {
                    id
                    description
                  }
                  isDefault
                  percentage
                }
                activitySubUnit {
                  id
                  tag
                }
              }
            }
          `,
          variables: {
            id: id,
            input: {
              dataCenter: dataCenterData.name,
              externalId: parseInt(dataCenterData.externalId),
              ayposURL: dataCenterData.ayposURL || "",
              number: parseInt(dataCenterData.number) || 1,
              areaId: dataCenterData.areaId || null,
              cityId: dataCenterData.cityId || null,
              address: dataCenterData.address || "",
              latitude: dataCenterData.latitude
                ? parseFloat(dataCenterData.latitude)
                : null,
              longitude: dataCenterData.longitude
                ? parseFloat(dataCenterData.longitude)
                : null,
              emissionScopeId: dataCenterData.emissionScopeId || null,
              sectorId: dataCenterData.sectorId || null,
              subSectorId: dataCenterData.subSectorId || null,
              dataCenterEmissionSources:
                dataCenterData.dataCenterEmissionSources || [],
              activitySubUnitId: dataCenterData.activitySubUnitId || null,
            },
          },
        },
        {
          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 getEmissionScopes = () => {
  return async (dispatch) => {
    dispatch({
      type: "GET_EMISSION_SCOPES_LOADING",
    });

    try {
      const response = await ApplicationService.http().post(
        "/graphql",
        {
          query: `
            query GetEmissionScopes {
              emissionScopes {
                id
                tag
                description
              }
            }
          `,
        },
        {
          headers: {
            Authorization: "Bearer " + localStorage.getItem("accessToken"),
          },
        }
      );

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

      dispatch({
        type: "GET_EMISSION_SCOPES_SUCCESS",
        payload: response.data.data.emissionScopes,
      });

      return response.data.data.emissionScopes;
    } catch (error) {
      console.error("Error fetching emission scopes:", error);
      dispatch({
        type: "GET_EMISSION_SCOPES_ERROR",
        payload: {
          error: error.message || "Failed to fetch emission scopes",
        },
      });
      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
                  physicalMachines {
                    id
                    name
                    vms {
                      id
                      vmName
                      state
                      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.physicalMachines) {
        dataCenter.physicalMachines.forEach((pm) => {
          if (pm.vms) {
            allVMs = allVMs.concat(pm.vms);
          }
        });
      }

      console.log("getDataCenterVMs: Found VMs:", allVMs);
      resolve(allVMs);
    } catch (error) {
      console.error("Error fetching VMs by data center:", error);
      resolve([]);
    }
  });
};