/* 
 * Implement atoi which converts a string to an integer.
 *
 * The function first discards as many whitespace characters as necessary until the first non-whitespace character is found. 
 * Then, starting from this character, takes an optional initial plus or minus sign followed by as many numerical digits as possible,
 * and interprets them as a numerical value.
 *
 * The string can contain additional characters after those that form the integral number, which are ignored and have no effect 
 * on the behavior of this function.
 *
 * If the first sequence of non-whitespace characters in str is not a valid integral number, or if no such sequence exists because
 * either str is empty or it contains only whitespace characters, no conversion is performed.
 * If no valid conversion could be performed, a zero value is returned.
 *
 * Note:
 * Only the space character ' ' is considered as whitespace character.
 * Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [−231,  231 − 1]. If the numerical value is out of the range of representable values, INT_MAX (231 − 1) or INT_MIN (−231) is returned.

*/
const assert = function(condition, message) {
  if(!condition) {
    console.error(` ${message}`);
  }
  console.log(` ${message}`);
}

/**
 * @param {string} str
 * @return {number}
 */
const myAtoi = function(str) {
    const INT_MAX = Math.pow(2,31) -1;
    const INT_MIN = Math.pow(2,31)* -1;
    let trimmedStr = str.trim();
    
    const valid = ['0', '1', '2','3','4','5','6','7','8','9', '-', '+'];
    const signs = ['-', '+'];

    if(
        !valid.includes(trimmedStr[0]) 
        || (trimmedStr.length === 1&& signs.includes(trimmedStr[0]))
       || (signs.includes(trimmedStr[0]) && signs.includes(trimmedStr[1]))
        || (signs.includes(trimmedStr[0]) && !valid.includes(trimmedStr[1]))
      ) {
        return 0;
    }
    

    const decimalIndx = str.indexOf('.');
    
    if (decimalIndx > -1){
        trimmedStr = str.substring(0, decimalIndx);
    }
    
    const isNeg = trimmedStr[0] === '-';
    const isPlus = trimmedStr[0] === '+';
    
 
    
    const queue = [];
    const list = trimmedStr.split('');
    for(let i = 0; i < list.length; i++){
        const char = list[i];
        if(!valid.includes(char) ||(signs.includes(char) && i > 0)) {
            break;
        }
            if(valid.includes(char)){
            queue.push(char);
        } 
    }
     
   if(isNeg){
       queue.shift();
   }
    if (isPlus){
        queue.shift();
    }
    let integer = parseInt(queue.pop(), 10);
    while(queue.length){
             let multipler = queue.length;
            let char = queue.shift();
            integer += (Math.pow(10,  multipler)* parseInt(char, 10));        
    }
    
    if(isNeg){
        integer= integer*-1;
    }

        if (integer >INT_MAX){
            return INT_MAX;
        } 
        if (integer < INT_MIN){
            return INT_MIN;
        }
        
        return integer;
    
};

/*
 * Test Case 1
 * Input: "42"
 * Output: 42
 */
x = '42';
sol = 42;
assert(myAtoi(x) === sol, 'Output: 42');
/* Explanation: The first non-whitespace character is '-', which is the minus sign.
 * Then take as many numerical digits as possible, which gets 42.
 */

/* Test Case 2
 * Input: "   -42"
 * Output: -42
 */
x = "    -42";
sol = -42;
assert(myAtoi(x) === sol, 'Output: -42');

/* Test Case 3
 * Input: "4193 with words"
 * Output: 4193
 */
x = '4193 with words';
sol = 4193;
assert(myAtoi(x) === sol, 'Output: 4193');
/* Explanation: Conversion stops at digit '3' as the next character is not a numerical digit.
*/

/*  Test Case 4
 * Input: "words and 987"
 * Output: 0
 */
x = 'words and 987';
sol = 0;
assert(myAtoi(x) === sol, 'Output: 0');
/* Explanation: The first non-whitespace character is 'w', which is not a numerical digit or a +/- sign. 
 * Therefore no valid conversion could be performed.
 */

/* Test Case 5 
 * Input: "-91283472332"
 * Output: -2147483648
 */ 

x = '-91283472332';
sol = -2147483648;
assert(myAtoi(x) === sol, 'Output: -2147483648');
/*Explanation: The number "-91283472332" is out of the range of a 32-bit signed integer.
 * Thefore INT_MIN (−231) is returned.
*/