import AbstractModel from '../models/Abstract';
import AbstractCollection from '../collections/Abstract';
import ajaxAdapterMock from './mocks/service/AjaxAdapter';
import { store } from '../setupTests';
import entityReducer from '../reducers/entity';
import { combineReducers } from 'redux';
import StorageError from '../errors/StorageError';
import ROLES from '../rolesConfig';


class EmployeeModel extends AbstractModel {
    static get urlRoot () {
        return 'employees';
    }

    static get ENTITY_TYPE () {
        return 'employees';
    }
}

class EmployeesCollection extends AbstractCollection {
    static get model () {
        return EmployeeModel;
    }
    getModels() {
        return this.models;
    }
}



class RoleModel extends AbstractModel {
    static get urlRoot () {
        return 'roles';
    }

    static get ENTITY_TYPE () {
        return 'roles';
    }
}

class RolesCollection extends AbstractCollection {
    static get model () {
        return RoleModel;
    }
    getModels() {
        return this.models;
    }
}

export const generateEmployeeModel = (empty = true, count) => {
    return new EmployeeModel(empty ? {} : {
        aseFunction: 1,
        displayName: null,
        status: 'enabled',
        endDate: null,
        firstName: "Admin" + count,
        hireDate: "2018-07-31T00:00:00+03:00",
        id: "04637ac1-6e51-11e8-9e8d-1256795c62d" + (count+ 5),
        lastName: "Mirro",
        position:{
            id: 1,
            name: "Senior System Administrator",
            shortName: "SSA"
        }
    });
};

export const generateEmployeesCollection = (nr = 0) => {
    const models = [];
    const collection = new EmployeesCollection();
    for (let i = 0; i < nr; i++) {
        models.push(generateEmployeeModel(false, i+1));
        collection.set(i, models[i]);
    }

    return collection;
};

export const generateCollection = (nr = 0) => {
    const models = [];
    for (let i = 0; i < nr; i++) {
        models.push(generateRole(false, i+1));
    }
    return models;
};

export const generateRole = (empty = true, count) => {
    const randomRole = Object.keys(ROLES).filter(role => ROLES[role] === count+1);

    return new RoleModel(empty ? {} : {
        'description': 'Lorem Ipsum ' + count,
        'name': 'Role Name ' + count,
        'enabled': 1,
        'id': count,
        'role': randomRole,
        'userCount': count + 3,
    });
};



export const setupFailGetDetailsCall = () => {
    const headers = new Headers();
    headers.append('Content-Type', 'application/json');
    global.fetch.mockResponseOnce('{}',
        {'status': 404, headers, statusText: 'Not found'});
    const err = new StorageError();
    err.setData({status: 404});
    ajaxAdapterMock.handleResponse.mockReturnValue(Promise.reject(err));
};

export const setupGetListSuccessCall = () => {
    const headers = new Headers(),
        data = [];
    headers.append('Content-Type', 'application/json');
    for (let i = 0; i < 20; i++) {
        data.push(generateRole(false).toJson());
    }
    const body = JSON.stringify({
        error: null,
        data,
        metadata: null,
    });
    global.fetch.mockResponseOnce(body, {'status': 200, headers});
    ajaxAdapterMock.handleResponse.mockReturnValue(Promise.resolve({
        body: JSON.parse(body),
    }));
};

export const setupGetList400Call = () => {
    const headers = new Headers();
    headers.append('Content-Type', 'application/json');
    global.fetch.mockResponseOnce('{}',
        {'status': 400, headers, statusText: 'Bad request'});
    const err = new StorageError();
    err.setData({status: 400});
    ajaxAdapterMock.handleResponse.mockReturnValue(Promise.reject(err));
};

const reducers = combineReducers({
    entity: entityReducer
});
store.replaceReducer(reducers);
export { RoleModel, RolesCollection };