import { UserData } from '../../domain/entities/user.entity';
import { RoleData } from '../../domain/entities/role.entity';
import { PermissionData } from '../../domain/entities/permission.entity';

export class PrismaUserMapper {
    static toDomain(model: any): UserData {
    const roles: RoleData[] = (model.userRoles || model.roles || []).map((ur: any) => {
          const r = ur.role || ur.role;
          const permissions: PermissionData[] = (r?.permissions || []).map((rp: any) =>
            PermissionData.restore({
              id: rp.permission.id,
              name: rp.permission.name,
              description: rp.permission.description,
              createdAt: rp.permission.createdAt,
              updatedAt: rp.permission.updatedAt,
            }),
          );

          return RoleData.restore({
            id: r.id,
            code: r.code,
            name: r.name,
            description: r.description,
            permissions,
            createdAt: r.createdAt,
            updatedAt: r.updatedAt,
          });
        });

    const permissions: PermissionData[] = (model.userPermissions || model.permissions || []).map((up: any) =>
          PermissionData.restore({
            id: up.permission?.id || up.id,
            name: up.permission?.name || up.name,
            description: up.permission?.description || up.description,
            createdAt: up.permission?.createdAt || up.createdAt,
            updatedAt: up.permission?.updatedAt || up.updatedAt,
          }),
        );

    return UserData.restore({
      id: model.id,
      authentikId: model.authentikUserId || model.authentikId || null,
      username: model.username || model.name || model.username,
      email: model.email,
      roles,
      permissions,
      isActive: model.isActive ?? true,
      deletedAt: model.deletedAt || null,
      lastSeenAt: model.lastSeenAt || null,
      storageQuota: model.storageQuota !== undefined && model.storageQuota !== null ? Number(model.storageQuota) : undefined,
      storageUsed: model.storageUsed !== undefined && model.storageUsed !== null ? Number(model.storageUsed) : undefined,
    });
  }

    static toPersistence(userData: UserData) {
        return {
          id: userData.id,
          authentikUserId: (userData as any).authentikUserId || userData.authentikId,
          authentikId: userData.authentikId,
          username: userData.username,
          email: userData.email,
          isActive: userData.isActive,
          deletedAt: userData.deletedAt,
          lastSeenAt: userData.lastSeenAt,
          lastSyncedAt: (userData as any).lastSyncedAt,
          syncStatus: (userData as any).syncStatus,
          storageQuota: (userData as any).storageQuota,
          storageUsed: (userData as any).storageUsed,
        };
  }
}