import { EmailAddress, Result, UniqueID } from "@common/domain";
import { User, Username } from "@contexts/auth/domain";
import { UserModel } from "../sequelize";

export interface IUserMapper {
  toDomain(entity: UserModel): Result<User, Error>;
  toDomainArray(entities: UserModel[]): Result<User[], Error>;

  toPersistence(aggregate: User): UserModel;
  toPersistenceArray(users: User[]): UserModel[];
}

class UserMapper implements IUserMapper {
  /**
   * 🔹 Convierte una entidad de la base de datos en un agregado de dominio `User`
   */
  toDomain(entity: UserModel): Result<User, Error> {
    if (!entity) {
      return Result.fail(new Error("Entity not found"));
    }

    // Crear Value Objects asegurando que sean válidos
    const uniqueIdResult = UniqueID.create(entity.id);
    const usernameResult = Username.create(entity.username);
    const emailResult = EmailAddress.create(entity.email);

    // Validar que no haya errores en la creación de los Value Objects
    const okOrError = Result.combine([uniqueIdResult, usernameResult, emailResult]);
    if (okOrError.isFailure) {
      return Result.fail(okOrError.error.message);
    }

    // Crear el agregado de dominio
    return User.create(
      {
        username: usernameResult.data!,
        email: emailResult.data!,
        roles: [],
        //roles: entity.roles || [],
      },
      uniqueIdResult.data!
    );
  }

  /**
   * 🔹 Convierte un array de entidades de la base de datos en un array de agregados de dominio `User`
   */
  toDomainArray(entities: UserModel[]): Result<User[], Error> {
    if (!Array.isArray(entities) || entities.length === 0) {
      return Result.fail(new Error("Entities array is empty or invalid"));
    }

    const usersResults = entities.map(this.toDomain);

    const okOrError = Result.combine(usersResults);
    if (okOrError.isFailure) {
      return Result.fail(okOrError.error);
    }

    const result = usersResults.map((result) => result.data!);
    return Result.ok(result);
  }

  /**
   * 🔹 Convierte un agregado `User` en un objeto listo para persistencia
   */
  toPersistence(user: User): UserModel {
    return user.toPersistenceData();
  }

  /**
   * 🔹 Convierte un array de agregados `User` en un array de objetos listos para persistencia
   */
  toPersistenceArray(users: User[]): UserModel[] {
    if (!Array.isArray(users) || users.length === 0) {
      return [];
    }

    return users.map(this.toPersistence);
  }
}

const userMapper: IUserMapper = new UserMapper();
export { userMapper };