import { GraphQLError } from "graphql";
import {
  AddUserToOrganizationInput,
  CreateOrganizationInput,
  CreateOrganizationInvitationInput,
  OrganizationAPITestResponse,
  OrganizationInvitationResponse,
  OrganizationInvitationsResponse,
  OrganizationPermissionsResponse,
  OrganizationResponse,
  OrganizationRolesResponse,
  OrganizationsListResponse,
  OrganizationUsersResponse,
  RemoveUserFromOrganizationInput,
  UpdateOrganizationInput,
  UpdateUserOrganizationRolesInput,
} from "../../../types/Organization";
import { GraphQLContext } from "../../context/types";
import {
  acceptOrganizationInvitation,
  addUserToOrganization,
  createOrganization,
  createOrganizationInvitation,
  deleteOrganization,
  getOrganization,
  getOrganizationInvitations,
  getOrganizationPermissions,
  getOrganizationRoles,
  getOrganizations,
  getOrganizationUsers,
  getUserOrganizations,
  removeUserFromOrganization,
  resendOrganizationInvitation,
  revokeOrganizationInvitation,
  testOrganizationsAPI,
  updateOrganization,
  updateUserOrganizationRoles,
} from "./organizationService";

export const organizationResolvers = {
  Query: {
    async testOrganizationsAPI(): Promise<OrganizationAPITestResponse> {
      try {
        const result = await testOrganizationsAPI();
        return result;
      } catch (error) {
        console.error("Erreur dans testOrganizationsAPI resolver:", error);
        return {
          available: false,
          message: error instanceof Error ? error.message : "Erreur lors du test de l'API",
        };
      }
    },

    async organizations(
      _parent: unknown,
      args: { page?: number; pageSize?: number }
    ): Promise<OrganizationsListResponse> {
      try {
        const { page = 1, pageSize = 10 } = args;
        const result = await getOrganizations(page, pageSize);

        return {
          success: true,
          organizations: result.organizations,
          totalCount: result.totalCount,
        };
      } catch (error) {
        console.error("Erreur dans organizations resolver:", error);
        return {
          success: false,
          message: error instanceof GraphQLError ? error.message : "Erreur lors de la récupération des organisations",
        };
      }
    },

    async organization(_parent: unknown, args: { id: string }): Promise<OrganizationResponse> {
      try {
        const organization = await getOrganization(args.id);

        if (!organization) {
          return {
            success: false,
            message: "Organisation non trouvée",
          };
        }

        return {
          success: true,
          organization,
        };
      } catch (error) {
        console.error("Erreur dans organization resolver:", error);
        return {
          success: false,
          message: error instanceof GraphQLError ? error.message : "Erreur lors de la récupération de l'organisation",
        };
      }
    },

    async organizationUsers(
      _parent: unknown,
      args: { organizationId: string; page?: number; pageSize?: number }
    ): Promise<OrganizationUsersResponse> {
      try {
        const { organizationId, page = 1, pageSize = 10 } = args;
        const result = await getOrganizationUsers(organizationId, page, pageSize);

        return {
          success: true,
          users: result.users,
          totalCount: result.totalCount,
        };
      } catch (error) {
        console.error("Erreur dans organizationUsers resolver:", error);
        return {
          success: false,
          message: error instanceof GraphQLError ? error.message : "Erreur lors de la récupération des utilisateurs",
        };
      }
    },

    async organizationRoles(
      _parent: unknown,
      args: { organizationId: string; page?: number; pageSize?: number }
    ): Promise<OrganizationRolesResponse> {
      try {
        const { organizationId, page = 1, pageSize = 10 } = args;
        const result = await getOrganizationRoles(organizationId, page, pageSize);

        return {
          success: true,
          roles: result.roles,
          totalCount: result.totalCount,
        };
      } catch (error) {
        console.error("Erreur dans organizationRoles resolver:", error);
        return {
          success: false,
          message: error instanceof GraphQLError ? error.message : "Erreur lors de la récupération des rôles",
        };
      }
    },

    async organizationPermissions(
      _parent: unknown,
      args: { organizationId: string; page?: number; pageSize?: number }
    ): Promise<OrganizationPermissionsResponse> {
      try {
        const { organizationId, page = 1, pageSize = 10 } = args;
        const result = await getOrganizationPermissions(organizationId, page, pageSize);

        return {
          success: true,
          permissions: result.permissions,
          totalCount: result.totalCount,
        };
      } catch (error) {
        console.error("Erreur dans organizationPermissions resolver:", error);
        return {
          success: false,
          message: error instanceof GraphQLError ? error.message : "Erreur lors de la récupération des permissions",
        };
      }
    },

    async organizationInvitations(
      _parent: unknown,
      args: { organizationId: string; page?: number; pageSize?: number }
    ): Promise<OrganizationInvitationsResponse> {
      try {
        const { organizationId, page = 1, pageSize = 10 } = args;
        const result = await getOrganizationInvitations(organizationId, page, pageSize);

        return {
          success: true,
          invitations: result.invitations,
          totalCount: result.totalCount,
        };
      } catch (error) {
        console.error("Erreur dans organizationInvitations resolver:", error);
        return {
          success: false,
          message: error instanceof GraphQLError ? error.message : "Erreur lors de la récupération des invitations",
        };
      }
    },

    async myOrganizations(
      _parent: unknown,
      args: { page?: number; pageSize?: number },
      context: GraphQLContext
    ): Promise<OrganizationsListResponse> {
      try {
        // DEBUG: log du contexte d'authentification
        console.log("[myOrganizations] context.user:", context.user);
        console.log("[myOrganizations] context.userId:", context.userId);
        if (context.request && typeof context.request.headers?.get === "function") {
          console.log("[myOrganizations] Authorization header:", context.request.headers.get("Authorization"));
        }
        const userId = context.user?.id || context.userId;
        if (!userId) {
          return {
            success: false,
            message: "Authentification requise",
          };
        }

        const { page = 1, pageSize = 10 } = args;
        const result = await getUserOrganizations(userId, page, pageSize);

        return {
          success: true,
          organizations: result.organizations,
          totalCount: result.totalCount,
        };
      } catch (error) {
        console.error("Erreur dans myOrganizations resolver:", error);
        return {
          success: false,
          message:
            error instanceof GraphQLError ? error.message : "Erreur lors de la récupération de vos organisations",
        };
      }
    },
  },

  Mutation: {
    async createOrganization(
      _parent: unknown,
      args: { input: CreateOrganizationInput }
    ): Promise<OrganizationResponse> {
      try {
        const organization = await createOrganization(args.input);

        return {
          success: true,
          organization,
          message: "Organisation créée avec succès",
        };
      } catch (error) {
        console.error("Erreur dans createOrganization resolver:", error);
        return {
          success: false,
          message: error instanceof GraphQLError ? error.message : "Erreur lors de la création de l'organisation",
        };
      }
    },

    async updateOrganization(
      _parent: unknown,
      args: { input: UpdateOrganizationInput }
    ): Promise<OrganizationResponse> {
      try {
        const organization = await updateOrganization(args.input);

        return {
          success: true,
          organization,
          message: "Organisation mise à jour avec succès",
        };
      } catch (error) {
        console.error("Erreur dans updateOrganization resolver:", error);
        return {
          success: false,
          message: error instanceof GraphQLError ? error.message : "Erreur lors de la mise à jour de l'organisation",
        };
      }
    },

    async deleteOrganization(_parent: unknown, args: { id: string }): Promise<OrganizationResponse> {
      try {
        await deleteOrganization(args.id);

        return {
          success: true,
          message: "Organisation supprimée avec succès",
        };
      } catch (error) {
        console.error("Erreur dans deleteOrganization resolver:", error);
        return {
          success: false,
          message: error instanceof GraphQLError ? error.message : "Erreur lors de la suppression de l'organisation",
        };
      }
    },

    async addUserToOrganization(
      _parent: unknown,
      args: { input: AddUserToOrganizationInput }
    ): Promise<OrganizationResponse> {
      try {
        await addUserToOrganization(args.input);

        return {
          success: true,
          message: "Utilisateur ajouté à l'organisation avec succès",
        };
      } catch (error) {
        console.error("Erreur dans addUserToOrganization resolver:", error);
        return {
          success: false,
          message: error instanceof GraphQLError ? error.message : "Erreur lors de l'ajout de l'utilisateur",
        };
      }
    },

    async removeUserFromOrganization(
      _parent: unknown,
      args: { input: RemoveUserFromOrganizationInput }
    ): Promise<OrganizationResponse> {
      try {
        await removeUserFromOrganization(args.input);

        return {
          success: true,
          message: "Utilisateur supprimé de l'organisation avec succès",
        };
      } catch (error) {
        console.error("Erreur dans removeUserFromOrganization resolver:", error);
        return {
          success: false,
          message: error instanceof GraphQLError ? error.message : "Erreur lors de la suppression de l'utilisateur",
        };
      }
    },

    async updateUserOrganizationRoles(
      _parent: unknown,
      args: { input: UpdateUserOrganizationRolesInput }
    ): Promise<OrganizationResponse> {
      try {
        await updateUserOrganizationRoles(args.input);

        return {
          success: true,
          message: "Rôles de l'utilisateur mis à jour avec succès",
        };
      } catch (error) {
        console.error("Erreur dans updateUserOrganizationRoles resolver:", error);
        return {
          success: false,
          message: error instanceof GraphQLError ? error.message : "Erreur lors de la mise à jour des rôles",
        };
      }
    },

    async createOrganizationInvitation(
      _parent: unknown,
      args: { input: CreateOrganizationInvitationInput }
    ): Promise<OrganizationInvitationResponse> {
      try {
        const invitation = await createOrganizationInvitation(args.input);

        return {
          success: true,
          invitation,
          message: "Invitation créée avec succès",
        };
      } catch (error) {
        console.error("Erreur dans createOrganizationInvitation resolver:", error);
        return {
          success: false,
          message: error instanceof GraphQLError ? error.message : "Erreur lors de la création de l'invitation",
        };
      }
    },

    async resendOrganizationInvitation(
      _parent: unknown,
      args: { invitationId: string }
    ): Promise<OrganizationInvitationResponse> {
      try {
        const invitation = await resendOrganizationInvitation(args.invitationId);

        return {
          success: true,
          invitation,
          message: "Invitation renvoyée avec succès",
        };
      } catch (error) {
        console.error("Erreur dans resendOrganizationInvitation resolver:", error);
        return {
          success: false,
          message: error instanceof GraphQLError ? error.message : "Erreur lors du renvoi de l'invitation",
        };
      }
    },

    async revokeOrganizationInvitation(
      _parent: unknown,
      args: { invitationId: string }
    ): Promise<OrganizationInvitationResponse> {
      try {
        await revokeOrganizationInvitation(args.invitationId);

        return {
          success: true,
          message: "Invitation révoquée avec succès",
        };
      } catch (error) {
        console.error("Erreur dans revokeOrganizationInvitation resolver:", error);
        return {
          success: false,
          message: error instanceof GraphQLError ? error.message : "Erreur lors de la révocation de l'invitation",
        };
      }
    },

    async acceptOrganizationInvitation(
      _parent: unknown,
      args: { invitationId: string }
    ): Promise<OrganizationInvitationResponse> {
      try {
        const invitation = await acceptOrganizationInvitation(args.invitationId);

        return {
          success: true,
          invitation,
          message: "Invitation acceptée avec succès",
        };
      } catch (error) {
        console.error("Erreur dans acceptOrganizationInvitation resolver:", error);
        return {
          success: false,
          message: error instanceof GraphQLError ? error.message : "Erreur lors de l'acceptation de l'invitation",
        };
      }
    },
  },
};