class BypassUsersModel extends EICPluralModel {
    
    constructor(privileges) {

        super('users', privileges); 
        
        this.singletonClass = class {
            itemData = {
                uuid: null,
                firstname: null,
                lastname: null,
                role: null
            }
        }
    }

    getUid(uid) {
        return(this.collection.find(x=>(x.uid == uid)));
    }

    create(payload) {
        if(!this.hasPrivilege('create')) return( new Promise((resolve, reject) => reject()))
        let endpoint = this.getApiEndpoint('create');
        return ( this.request(endpoint.uri, endpoint.method, payload) );
    }

    revoke(uid) {
        if(!this.hasPrivilege('revoke')) return( new Promise((resolve, reject) => reject()))
        
        let endpoint = this.getApiEndpoint('revoke');
        let uri = endpoint.uri.replace('{id}', uid);
        
        return this.request(uri, endpoint.method, null);
    }

    search(hint) {
        // This is publicly avail, don't check until ML understand what anonymous means
        // if(!this.hasPrivilege('search')) return( new Promise((resolve, reject) => reject()))
        let endpoint = this.getApiEndpoint('search');
        let uri = endpoint.uri.replace('{id}', hint);

        return ( 
            this.request(uri, endpoint.method, {'hint': hint })
            .then( async serverData => {
                let users = serverData.payload.map(x=> { // Cleanup keys starting with https://
                    for(let k in x){ 
                        if(k.substring(0,4)=='http') { x[k.substring(k.lastIndexOf('/')+1)]=x[k]; delete(x[k]);} 
                    } return(x); 
                } )
                return(users);
            })
        )   
    }
    
    sanitize(item) {
        //TODO what if several BP_ roles...
        item.BProle = item.roles.filter(r => (r.substring(0,3)=='BP_'))[0];
        let trackTree = null;
        if(item.track) {
            trackTree = app.meta.getItem('accelerator-tracks',item.track);
            item.track = { id: item.track, label: trackTree.label };
        } else {
            item.track = { id: null, label: '(n/a)' };
        }

        if((item.domain) && (trackTree)){
            item.domain = { id: item.domain, label: app.meta.getItemRecurse(trackTree, item.domain).label };            
        } else  {
            item.domain = { id: null, label: '(n/a)' };
        }

        return item; 
    }

    list(filters) {
        if(!this.hasPrivilege('list')) return( new Promise((resolve, reject) => reject()))

        let endpoint = this.getApiEndpoint('list');        
        return ( 
            this.request(endpoint.uri, endpoint.method, filters)
            .then( async serverData => {
                const payload = serverData.payload;
                this.fill(payload);
            })
        )
    }

    // Not sure why / when / where they think I'll need it, but it exists (and takes 2.5 seconds to get 5 strings)
    // If someday the response-time is decent, and if we have the delegationRules the payload...maybe...
    getRoles() { 
        if(!this.hasPrivilege('getRoles')) return( new Promise((resolve, reject) => reject()))

        let endpoint = app.config.api.roles.list;        
        return ( 
            this.request(endpoint.uri, endpoint.method, {})
            .then( async serverData => {
                this.existingRoles = serverData.payload;
            })
        )
    }

    fill(serverData) {
        if(serverData && serverData.length) {
            this.collection = [];
            for(let singletonData of serverData) this.collection.push(this.sanitize(singletonData));
        }
    }
}

app.registerClass('BypassUsersModel', BypassUsersModel);