// Task 1. Функции высшего порядка.

//1.Создать две функции и дать им осмысленные названия:
//- первая функция принимает массив и колбэк (одна для всех вызовов)
//- вторая функция (колбэк) обрабатывает каждый элемент массива (для каждого вызова свой callback)

//Первая функция возвращает строку “New value: ” и результат обработки:

//firstFunc([‘my’, ‘name’, ‘is’, ‘Trinity’], handler1) → “New value: MyNameIsTrinity”
//firstFunc([10, 20, 30], handler2) → “New value: 100, 200, 300,”
//firstFunc([{age: 45, name: ‘Jhon’}, {age: 20, name: ‘Aaron’}], handler3) →
//“New value: Jhon is 45, Aaron is 20,”
//firstFunc([‘abc’, ‘123’], handler4) → “New value: cba, 321,” // строки инвертируются


//Подсказка: secondFunc должна быть представлена функцией, которая принимает
//один аргумент (каждый элемент массива) и возвращает результат его обработки

function changeString(arr, getNewString) {

    let newString = 'New value:';

    for (let i = 0; i < arr.length; i++) {
        newString += getNewString(arr[i]);
    }

    return console.log(newString);
}

function stickCamelCaseString(item) {

    return ' ' + item[0].toUpperCase() + item.slice(1);
}

function increaseTen(item) {

    return ' ' + (item *= 10) + ',';
}

function objectToString(item) {

    return ' ' + item.name + ' is ' + item.age + ',';
}

function invertString(item) {

    let newItem = '';

    for (let i = item.length - 1; i >= 0; i--) {
        newItem += item[i];
    }

    return ' ' + newItem + ',';
}

changeString(['my', 'name', 'is', 'Trinity'], stickCamelCaseString);
changeString([10, 20, 30], increaseTen);
changeString([{ age: 45, name: 'Jhon' }, { age: 20, name: 'Aaron' }], objectToString);
changeString(['abc', '123'], invertString);

//2.Написать аналог метода every. Создайте функцию every, она должна принимать первым аргументом массив чисел
//(обязательно проверьте что передан массив) вторым аргументом callback
//функция должна возвращать true или false в зависимости от результата вызова callback (проверить число больше 5).
//Callback  должен принимать один элемент массива, его индекс в массиве и весь массив.

function every(arr, callback) {

    if (!Array.isArray(arr)) {

        return console.log('Error!');
    }

    for (let i = 0; i < arr.length; i++) {

        if (!callback(arr[i], i, arr)) {

            console.log('Not all items are valid');
            return false;
        }
    }
    console.log('All items are valid');
    return true;
}

function moreThanFive(item, index, arr) {

    if (item <= 5) {

        return true;
    }
    else {
        console.log(`Item ${item} with index ${index} in array ${arr} more than five`);
        return false;
    }
}

every([1, 2, 3, 8], moreThanFive);
every([1, 2, 5, -1], moreThanFive);

// Task 2. Перебирающие методы.

//1.На основе массива [1,2,3,5,8,9,10] сформировать новый массив, каждый элемент которого будет хранить информацию о числе и его четности:
//[{digit: 1, odd: true}, {digit: 2, odd: false}, {digit: 3, odd: true}...]

arr = [1, 2, 3, 5, 8, 9, 10];

let newArr = arr.map(function (item) {

    if (item % 2 === 0) {

        return { digit: item, odd: true };
    }
    else {

        return { digit: item, odd: false };
    }
});

console.log(newArr);

//2.Проверить, содержит ли массив [12, 4, 50, 1, 0, 18, 40] элементы, равные нулю. Если да - вернуть false.

arr = [12, 4, 50, 1, 0, 18, 40];
newArr = [12, 4, 50, 1, -5, 18, 40];

function haveZero(number) {

    return number === 0;
}

console.log(!arr.some(haveZero));
console.log(!newArr.some(haveZero));

//3.Проверить, содержит ли массив ['yes', 'hello', 'no', 'easycode', 'what'] хотя бы одно слово длиной больше 3х букв.
//Если да - вернуть true

arr = ['yes', 'hello', 'no', 'easycode', 'what'];
newArr = ['yes', 'no'];

function nameLength(name) {

    if (name.length > 3) {

        return true;
    }
}

console.log(arr.some(nameLength));
console.log(newArr.some(nameLength));

//4.Дан массив объектов, где каждый объект содержит информацию о букве и месте её положения в строке {буква: “a”, позиция_в_предложении: 1}:

//[{char:"a",index:12}, {char:"w",index:8}, {char:"Y",index:10}, {char:"p",index:3}, {char:"p",index:2},
//{char:"N",index:6}, {char:" ",index:5}, {char:"y",index:4}, {char:"r",index:13}, {char:"H",index:0},
//{char:"e",index:11}, {char:"a",index:1}, {char:" ",index:9}, {char:"!",index:14}, {char:"e",index:7}]

//Напишите функцию, которая из элементов массива соберет и вернёт строку, основываясь на index каждой буквы. Например:
//[{char:"H",index:0}, {char:"i",index: 1}, {char:"!",index:2}] → “Hi!”

//Подсказка: вначале отсортируйте массив по index, затем используйте reduce() для построения строки

arr = [{ char: "a", index: 12 }, { char: "w", index: 8 }, { char: "Y", index: 10 }, { char: "p", index: 3 }, { char: "p", index: 2 },
{ char: "N", index: 6 }, { char: " ", index: 5 }, { char: "y", index: 4 }, { char: "r", index: 13 }, { char: "H", index: 0 },
{ char: "e", index: 11 }, { char: "a", index: 1 }, { char: " ", index: 9 }, { char: "!", index: 14 }, { char: "e", index: 7 }];

arr.sort(function (a, b) {
    if (a.index > b.index) {
        return 1;
    }
    if (a.index < b.index) {
        return -1;
    }
    // a должно быть равным b
    return 0;
});

let builString = arr.reduce(function (res, current) {
    return res.concat(current.char);
}, '');

console.log(builString);

// Task 3. Метод Sort.

//1.Отсортируйте массив массивов так, чтобы вначале располагались наименьшие массивы (размер массива определяется его длиной):
//[  [14, 45],  [1],  ['a', 'c', 'd']  ] → [ [1], [14, 45], ['a', 'c', 'd'] ]

arr = [[14, 45], [1], ['a', 'c', 'd']];
console.log(arr);

arr.sort(function (a, b) {
    if (a.length > b.length) {
        return 1;
    }
    if (a.length < b.length) {
        return -1;
    }
    // a должно быть равным b
    return 0;
});

console.log(arr);

//2.Есть массив объектов:
// [
//     {cpu: 'intel', info: {cores:2, сache: 3}},
//     {cpu: 'intel', info: {cores:4, сache: 4}},
//     {cpu: 'amd', info: {cores:1, сache: 1}},
//     {cpu: 'intel', info: {cores:3, сache: 2}},
//     {cpu: 'amd', info: {cores:4, сache: 2}}
// ]

//Отсортировать их по возрастающему количеству ядер (cores).

arr = [
    { cpu: 'intel', info: { cores: 2, сache: 3 } },
    { cpu: 'intel', info: { cores: 4, сache: 4 } },
    { cpu: 'amd', info: { cores: 1, сache: 1 } },
    { cpu: 'intel', info: { cores: 3, сache: 2 } },
    { cpu: 'amd', info: { cores: 4, сache: 2 } }
];

arr.sort(function (a, b) {
    if (a.info.cores > b.info.cores) {
        return 1;
    }
    if (a.info.cores < b.info.cores) {
        return -1;
    }
    // a должно быть равным b
    return 0;
});

console.log(arr);

//3.Создать функцию, которая будет принимать массив продуктов и две цены. Функция должна вернуть все продукты,
//цена которых находится в указанном диапазоне, и сортировать от дешевых к дорогим:

// let products = [
//     {title: 'prod1', price: 5.2}, {title: 'prod2', price: 0.18},
//     {title: 'prod3', price: 15}, {title: 'prod4', price: 25},
//     {title: 'prod5', price: 18.9}, {title: 'prod6', price: 8},
//     {title: 'prod7', price: 19}, {title: 'prod8', price: 63}
// ];

//filterCollection(products, 15, 30) → [{...price: 15}, {...price: 18.9}, {...price: 19}, {...price: 25}]

let products = [
    {title: 'prod1', price: 5.2}, {title: 'prod2', price: 0.18},
    {title: 'prod3', price: 15}, {title: 'prod4', price: 25},
    {title: 'prod5', price: 18.9}, {title: 'prod6', price: 8},
    {title: 'prod7', price: 19}, {title: 'prod8', price: 63}
];

function filterCollection(products, minPrice, maxPrice){

    let resArr = products.filter(function(item) {
        return item.price >= minPrice && item.price <= maxPrice;
      });

    resArr.sort(function (a, b) {
        if (a.price > b.price) {
            return 1;
        }
        if (a.price < b.price) {
            return -1;
        }
        // a должно быть равным b
        return 0;
    });

    return resArr;
}

console.log(filterCollection(products, 15, 30));