var response = {};
var createdTypes = 0;
var createdEntities = 0;

var profileId = bridge.getProfileId();
var email = bridge.getEmail();
bridge.logInfo("running from ConvertUserEntitiesToCustomEntities script profileid: ", profileId);


var session = bridge.getSessionForProfile(profileId);
bridge.logInfo("running from ConvertUserEntitiesToCustomEntities script session: ", session);


// utiliser la pagination pour déterminer si besoin d'obtenir la page suivante
var maxperpage = 100;
var pageNumber = 1;

var context = {
    "pagination": {
        "rowsPerPage": maxperpage,
        "pageNumber": pageNumber
    },
    "searchCriteria": {
        
    },
    "sortCriteria": {
        "createdAt": 1,
        "updatedAt": -1
    }
};

var entityProxy = bridge.getEntityServiceProxy(session);

var firstPageResult = entityProxy.getPage(context);

if (firstPageResult.status == 200) {
    
    var count = firstPageResult.data.results.count;
    
    response.count = count;

    if(count>0){
        
        var customEntityProxy = bridge.getCustomEntityServiceProxy();
        
        var items = firstPageResult.data.results.items;
        
        // obtenir les types d'entités personnalisées existantes
        var collectionsResult = customEntityProxy.sysListCollections();
        
        // créer une array pour contenir les noms des types/collections actuels (le nom du type est unique et requis dans les entités personnalisées) 

        var arrTypes = [];
        var existCustomEntityTypes;
        
        if (collectionsResult.status == 200) {
            
            existCustomEntityTypes = collectionsResult.data.collections;
            
            for (var x in existCustomEntityTypes){
                
                //ajouter le nom des collections à cette array
                arrTypes.push(Object.keys(existCustomEntityTypes[x])[0]);
            }
            
        } else{
            response.getCustomEntityTypesErro = "error call sysListCollections";
        }
        
        
        bridge.logInfo("collection arrTypes before : ", arrTypes);
        
        response.existedCustomTypes = arrTypes;
        
        //modifier l'option si vous souhaitez passer à global
        var collectionOptsJson = {
            "isOwned": true,
            "migrate": false,
            "identifier": email
        };
        
        for (var i in items) {
            var entityType = items[i].entityType;
            
            response.entityType =  entityType;
            
            bridge.logInfo("check entity type : ", entityType);
            
            //vérifier les types d'entités personnalisées (arrTypes) s'ils contiennent ce type, en créer un sinon 
             response.checkTypeIncludes = arrTypes.includes(entityType);
            
            if (!arrTypes.includes(entityType)){
                var createCollectionResult = customEntityProxy.sysCreateCollection(entityType, collectionOptsJson);
                if (createCollectionResult.status == 200) {
                    //ajouter à l'array de vérification de type
                    arrTypes.push(entityType);
                    createdTypes ++;
                }else{
                    response.createCollectionError = "sysCreateCollection call errors from first page, check entityType you injected";
                }
            }
            
            //après avoir créé le type de collection, nous pouvons créer une entité personnalisée 
            
            var dataJson = items[i].data;
            var acl = items[i].acl;
            var timeToLive = null;
            var ownerId = profileId;
            var customEntityProxy = bridge.getCustomEntityServiceProxy();
            
            var createEntityResult = customEntityProxy.sysCreateEntity(entityType, dataJson, acl, timeToLive, ownerId);
            if (createEntityResult.status == 200) {
                bridge.logInfo("first page totally created "+ i +" custom entity(ies) with type : ", entityType);
                createdEntities ++;
            }
        }
        
        bridge.logInfo("collection arrTypes after firstpage looped throuhg and created custom entities: ", arrTypes);
        
        
        //si le nombre d'éléments renvoyés est supérieur à maxperpage, la boucle for sera utilisée pour appeler la page suivante, jusqu'à ce qu'elle soit entièrement analysée         
        
        var remainder = 0;
        var numberpage = 0;
        remainder = count % maxperpage;
        numberpage = (count-remainder)/maxperpage;
        
        response.remainder = remainder;
        response.numberpage = numberpage;
        
        bridge.logInfo("remainder: ", remainder);
        bridge.logInfo("numberpage: ", numberpage);
        
        for (var n = 0; n < numberpage; n++ ){
            
            pageNumber ++;
            
            context.pagination.pageNumber = pageNumber;
            
            response.nextpageContext = context; 
            bridge.logInfo("numberpage: ", numberpage);
            
            var nextPageResult = entityProxy.getPage(context);
            
            if (nextPageResult.status == 200) {
            
                var nextItems = nextPageResult.data.results.items;
                
                for (var y in nextItems) {
                    var entityType = nextItems[y].entityType;
                    
                    //vérifier les types d'entités personnalisées (arrTypes) s'ils contiennent ce type, en créer un sinon 
                    if (!arrTypes.includes(entityType)){
                        var createCollectionResult = customEntityProxy.sysCreateCollection(entityType, collectionOptsJson);
                        if (createCollectionResult.status == 200) {
                            //ajouter à l'array de vérification de type
                            arrTypes.push(entityType);
                            createdTypes ++;
                        }else{
                            response.createCollectionError = "sysCreateCollection call errors from next page, check entityType you injected";
                        }
                    }
                    
                    //après avoir créé le type de collection, nous pouvons créer une entité personnalisée 
                    var dataJson = nextItems[y].data;
                    var acl = nextItems[y].acl;
                    
                    var createEntityResult = customEntityProxy.sysCreateEntity(entityType, dataJson, acl, timeToLive, ownerId);
                    if (createEntityResult.status == 200) {
                        bridge.logInfo("page ("+ pageNumber + ") totally created "+ y +" custom entity(ies) with type : ", entityType);
                        createdEntities ++;
                    }
                }
            }else{
                response.getNextPageResultError = "get next page entities error";
            }
        }
        
        response.createdTypes = "totally created custom entity types : "+createdTypes;
        response.createdEntities = "totally created custom entities: "+createdEntities;
    }
}

response;