function func1(callback) { 
    console.log('hello'); 
    if (typeof callback === "function") { 
        callback();
    }
}

func1(function(){ 
    console.log('world');
}); 

//defining a promise: 
let promiseToCleanRoom = new Promise(function(resolve, reject) { 
    //cleaning the room
    let isClean = true; 

    if(isClean) { 
        resolve('Clean'); //Clean is the status of resolve 
    } else { 
        reject('Dirty'); 
    }
});

promiseToCleanRoom.then(function(fromResolve){  //"then" is a method that is called when the promise is resolved
    //then can have inside it a callback function which is eventually caled when the promise is resolved
    //Note that i can receive the status of resolve which is "Clean"
    console.log('the room is ' + fromResolve); //fromResolve = Clean
}).catch(function(fromReject){ 
    console.log('the room is ' + fromReject); 
}); //if we want to reject the promise, we can chain another method called "catch"  

let cleanRoom = function() {
  return new Promise(function(resolve, reject) {
    resolve('Cleaned The Room');
  });
};

let removeGarbage = function(message) {
  return new Promise(function(resolve, reject) {
    resolve(message + ' remove Garbage');
  });
};

let winIcecream = function(message) {
  return new Promise(function(resolve, reject) {
    resolve( message + ' won Icecream');
  });
};

cleanRoom().then(function(result){
	return removeGarbage(result);
}).then(function(result){
	return winIcecream(result);
}).then(function(result){
	console.log('finished ' + result);
})
// The shorter way: 
//   cleanRoom()
//   .then(removeGarbage)
//   .then(winIcecream)
//   .then(function(message) {
//     console.log('This is the message\n' + message);
//   });

var obj = { num:2 }; 
var addToThis = function(a, b, c) { 
    return this.num + a + b + c; 
};

console.log(addToThis.call(obj, 1, 2, 3)); //function_name.call(obj,function_arguments)
// so call attaches a method to an object as if this method is now part of the object

var arr = [1,2,3];
console.log(addToThis.apply(obj, arr)); //here i should use apply instead of call, because all the arguments of the function are now the arr. So in apply i should use an array for the function arguments. that's the only difference with call. 

//bind returns me a function that i can execute later on! so bind will bind me a method to an object without executing it yet! I will pass the arguments of that function on execution time 
var bound = addToThis.bind(obj); 
console.log(bound(1,2,3)); 
//alternatively you can use the spread operator: (here the spread operator ... is spreading the array to its single values because the array is on the left part of the "=" so it's in the execution part. If the spread operator was in the assignment part it would behave as a gathering operator) 
console.log(bound(...arr)); 

/*
The console object is available to us globally because it is a part of the global name space. So, by adding the global name space before this console log, this will actually work the same as without the "global." namespace 

Because the global name space is assumed, we do not have to always include it.
*/
global.console.log("hello world"); 

/*
Note: Let's see what happens when I create a variable. So, here I've created a variable for Hello, and that variable will be set to a string. If you're use to using javascript in the window (the global object of the web browser), you know that these variables are added to the global object. That means, we should be able to see our Hello variable by typing global.hello.
*/

var hello = "hello world";
console.log(global.hello); 

/*
this time when I run it, I see an undefined. That is because node js works a little bit different than the browser when it comes to storing variables. 

The Explanation: 
Every node js file that we create is it's own module. Any variable that we create in a node js file, is scoped only to that module. That means that our variables are not added to the global object the way that they are in the browser.
*/

// So we can't use the global namespace in that case:
var hello = "hello world";
console.log(global.hello); 

console.log(__dirname); //If I were to log __dirname. We would get the full path to the current directory where this module is located. 

console.log(__filename); //If I were to log__file name, we can get the full path to the current file as well as this file's name.

var path = require('path'); 

/*
The require function, is what we're going to use to import other node js modules.
The path module, is a module that is available to you with your installation of node js. It gives us some tools for working with paths. 
*/

console.log(process.argv); 
/*
we can see that the process.argv variable is an array. It contains a path to node, and a path to app.js. We started the app by running node. User/local/bin is the directory that that executable is found in. We also started this app.js file and we can see that we have the full path to that here.
*/

/*
Let's go ahead and write a message to the console just using standard output. process.stdout is our standard output object and we can use the write method to write some strings to the Terminal.
*/

process.stdout.write("What is your name?\n"); 

/*
Let's go ahead and add a listener to our program to listen for the answer to our question.
I'm going to wire up an event listener for data on the standard input object.
*/

process.stdin.on('data', function(data) { 
    process.stdout.write('\n' + data.toString().trim() + '\n'); 
    process.exit; // process.exit will cause the process to exit from within.
});

/*
So when a data event is raised, this means that when the user types some data into the Terminal and hits enter we will raise this data event here.

Role of the callback function:  So I'm going to go ahead and add a callback function to handle this.
So when the user enters some data, or when any data is sent to our application through the standard input object this callback function will fire and that data that is sent to our application will come in as an argument. 

So when there's any data sent to this application through the Terminal this callback function will fire and we will echo the data back by writing it to the Terminal and displaying it to our user. 
*/

process.on('exit', function() { 
    process.stdout.write("BYE!\n"); 
});

/*
process.on('exit', callback_function()) will listen for an exit event on the process object.

And when the process.exit is invoked this callback function will fire. So when we exit the process we can do a couple of things just before the process exits.
*/

setTimeout(callback_function, waiting_time)

//setInterval:
var currentTime = 0;
var waitInterval = 500; 

var interval = setInterval(function() { 
    currentTime += waitInterval; 
    console.log (`
    Waiting for: ${currentTime/1000} seconds
    `);
}, waitInterval); 

// setTimeout will create a delay of a certain time and then invoke a callback function. 
var waitTime = 3000; 
console.log("wait for it!");

setTimeout(function() { 
        clearInterval(interval); 
        console.log("done"); 
}, waitTime); //So what we're going to do is invoke this function after our delay

/*
. What we're going to do is cause a timeout that will cause this application to wait for three seconds and then it will invoke this callback function where we will simply console.log a done. 
*/

var path = require('path'); 
console.log(path.basename(__filename)); ////We use the path module for instance to pluck the base file name from a full path

var dirUploads = path.join(__dirname, 'www', 'files', 'test'); // We can also use the path module to create path strings. The path dot join function can be used to join strings together in a path. 
console.log(dirUploads); 

/*
The utilities module is called util. The utilities module has several helper functions that we can use. One of which is a log. So instead of doing console logs, I can do util logs. And, the difference is we're still going to log this information to the console. The utilitie module log function also adds a date and time stamp. 
*/
var util = require('util'); 
util.log('hello world'); 

/*
Since, no JS is built on top of Google Chrome's v8 processor, we can use the v8 module to get information about memory.
*/
var v8 = require('v8'); 
console.log(v8.getHeapStatistics()); 

var readline = require('readline'); 
//once I have readline, I can create an instance of the readline object which will create prompt for me by sending it the standard input and standard output objects.

var rl = readline.createInterface(process.stdin, process.stdout); 
/*
So var rl will be my readline instance and I will use readline to create an interface. With this interface, we're going to send it the process.stdin and process.stdout.

Readline is going to control these objects for us asking questions and collecting information so that we don't have to control the process.stdin and stdout directly.
*/

rl.question("what is the name of a real person?", function(answer){
    console.log(answer); 
});

/*
 In order to ask a question of Readline, all you need to do is invoke rl.question. And the first argument will be the question that will show up in the Terminal. We will ask, "What is the name of a real person?" The second argument is the function that will invoke once we have an answer from the Terminal. And in this function, the answer will be sent as an argument.

We can go ahead and just log that answer to the console. 
*/

var readline = require('readline');
var rl = readline.createInterface(process.stdin, process.stdout);

var realPerson = {
	name: '',
	sayings: []
};


rl.question("What is the name of a real person? ", function(answer) {

	realPerson.name = answer;

	rl.setPrompt(`What would ${realPerson.name} say? `);

	rl.prompt();

	rl.on('line', function(saying) {

		realPerson.sayings.push(saying.trim());

		if (saying.toLowerCase().trim() === 'exit') {
			rl.close();
		} else {
			rl.setPrompt(`What else would ${realPerson.name} say? ('exit' to leave) `);
		    rl.prompt();
		}

	});

});


rl.on('close', function() {

	console.log("%s is a real person that says %j", realPerson.name, realPerson.sayings);
	process.exit();
	
});

var events = require('events'); 

var emitter = new events.EventEmitter(); 
//the EventEmitter itself is a constructor. So, I'm going to create a new instance of a variable called emitter. This object that we created has "on" and "emit" functions 

emitter.on('customEvent', function(message, status){ 
    console.log(`${status}: ${message}`);
})
/*
So, every time we use on, we can wire up a custom event. You can name an event whatever you like. In this case, I've just called this customEvent. The second argument that the on function takes is a callback function that will be invoked when the custom event is raised. In this case, our custom event is going to pass a message and a status to this function as arguments. So, when our custom event occurs, this callback function will be invoked asynchronously. 

So, when a custom event is raised, we'll pass a message and a status to this callback function asynchronously, and we're just going to log that message in status.

The next part of the EventEmitter is the ability to trigger or emit custom events. We can trigger or emit a custom event with the emit function.
*/

emitter.emit('customEvent', 'hello world', 200); // So, emitter.emit will fire our custom event.

/*
The first argument is the event name that we want to fire. And then, the next arguments are going to be the arguments that will passed to the callback function. So, the first argument in the callback function, the message, is actually the second argument of this emit function. So, for the message, I will send Hello World. And the third argument is going to be the second argument in the callback. So, I will send a status of 200. In this code, we've created a new instance of the EventEmitter object, and we wired up a listener to listen for custom events.
*/

//I'm going to create a var called util, and I'm going to require our utilities module. The utilities module has an inherits function, and it's a way that we can add a object to the prototype of an existing object. That's how JavaScript handles inheritance. 

/*

The first thing that I want to do is instead of including just the events up here on line one, we can actually pull the EventEmitter out of events directly in this require statement here. So, I will use EventEmitter as a variable. And then, I can just chain on to the end of this require statement EventEmitter. And that will pull that constructor function out of the events module and set this variable to our new constructor function.

*/
var EventEmitter = require('events').EventEmitter;
var util = require('util');

var Person = function(name) {
	this.name = name;
};

util.inherits(Person, EventEmitter);

var ben = new Person("Ben Franklin");

ben.on('speak', function(said) {

	console.log(`${this.name}: ${said}`);

});


ben.emit('speak', "You may delay, but time will not.");

var Person = require("./file2"); //When requiring modules, we do not include the .js extension, it just assumes that this file is Javascript, so we are looking for the person Javascript module.

var ben = new Person("Ben Franklin");
var george = new Person("George Washington");


george.on('speak', function(said) {

	console.log(`${this.name} -> ${said}`);

});

ben.on('speak', function(said) {

	console.log(`${this.name}: ${said}`);

});


ben.emit('speak', "You may delay, but time will not.");
george.emit('speak', "It is far better to be alone, than to be in bad company.");

//This is our reusable module

//Now that we have this code here, these variables that we create in this file are local to this module. 

//That means that everything in this file is private and cannot be consumable by another module. If we would like to make items consumable by other Javascript files, we can export them on module export.


var EventEmitter = require('events').EventEmitter;
var util = require('util');

var Person = function(name) {
	this.name = name;
};

util.inherits(Person, EventEmitter);


module.exports = Person;
/*
Module.exports is a Javascript object. We can use it like any Javascript object. We can dot notate on it, bracket notate, set it to an object literal or any Javascript type. In this case, I'm setting module.exports to our person constructor function.

Module.exports is the object that is returned by the require statement. When we require this module, we will return anything that is on module.exports. 
*/

/*
The Child Process module contains the execute function, so I'm just going to chain this on the end so I can pluck it out into my execute variable. Now with the exec function I can execute commands. I can exec, for instance, an open, and now when I actually save and run this node module we will go ahead and excecute a ls -la. 
*/

const { exec } = require('child_process'); 
/* 
In the above line we have a destructuring:
It's a shorthand for: 

const {exec: exec} = require('child_process');
    Or

var exec = require('child_process').exec;
*/
exec('ls -la', function(err, output, std_err){ 
    if (err) { 
        throw err; 
    }
    console.log(output);    
    if (std_err) { 
        console.log(std_err);    
    }
        
});

// Now every time we've been executing any of these processes any data that gets returned by the process would be returned to the second argument in the execute function, a call back function.

var spawn = require("child_process").spawn;

var cp = spawn("node", ["alwaysTalking"]); 
/* So now I have my spawn function set up. This time I'm going to create a variable for the child process, and that will be returned by my spawn function. The first argument that I'm going to send to the spawn function is the command that I want to run in the terminal. That is node. The second argument is going to be an array of all of the things that I would run after the node command.

So in order to run the alwaysTalking app we will node alwaysTalking in the command line, so I'll just go ahead and put alwaysTalking or the options that would show up in the command line after node into an array, which represents the second argument of the spawn function.
*/

cp.stdout.on("data", function(data) {
	console.log(`STDOUT: ${data.toString()}`);
});

cp.on("close", function() {

	console.log("Child Process has ended");

	process.exit();

});


setTimeout(function() {

	cp.stdin.write("stop");

}, 4000);

var sayings = [
    "You may delay, but time will not.",
    "Tell me and I forget. Teach me and I remember. Involve me and I learn.",
    "It takes many good deeds to build a good reputation, and only one bad one to lose it.",
    "Early to bed and early to rise makes a man healthy, wealthy and wise.",
    "By failing to prepare, you are preparing to fail.",
    "An investment in knowledge pays the best interest.",
    "Well done is better than well said."
];

var interval = setInterval(function() {
	var i = Math.floor(Math.random() * sayings.length);
	process.stdout.write(`${sayings[i]} \n`);
}, 1000);

process.stdin.on('data', function(data) {
	console.log(`STDIN Data Recieved -> ${data.toString().trim()}`);
	clearInterval(interval);
	process.exit();
});

var fs = require("fs"); 
var files = fs.readdirSync('./folder_name'); 
console.log(files); 

var fs = require("fs");

fs.readdir('./folder_name', function(err, files) {
	if (err) {
		throw err;
	}
	console.log(files);
});

console.log("Reading Files...");

var fs = require("fs"); 
var contents = fs.readFileSync('./file_name', 'UTF-8');
/* 
if we ommit UTF-8 it will read it as a binary 
console.log(contents);
And binary files in Node.js are handled with the Node.js buffer class. 

var fs = require("fs"); 
var path = require("path"); 

fs.readdir("../My Files", function(err, files_array){ 
    files_array.forEach(function(fileName){ 
        var file = path.join('../My Files', fileName); 
        var stats = fs.statSync(file); //it will tell wether it's a file or directory
        if (stats.isFile() && fileName !== '.DS_Store') { 
            fs.readFile(file, 'UTF-8', function(err, contents){ 
                if (err) { 
                    console.log(err); //logging the erro won't kill the process, but throwing it will! be careful
                }
                console.log(contents);
            });
        }

    })
});

var fs = require("fs"); 
var md = `hello world`;
//creating a file asynchronously 
fs.writeFile("file_to_create.extension", "file_content_to_add", function(err){
    if (err) { 
        console.err(err); 
    }
    console.log("file created");
});

//appending content to an existing file asynchronously 
fs.appendFile("already_create_file.extension", "content_to_append", function(err){ 
        if (err) { 
        console.err(err); 
        }
         console.log("content appendded");
});

var fs = require("fs");

if (fs.existsSync("dir_name")) { //checking for the existence of a directory. exists can also be used to check for the existence of a file. Here we are using the synchronous version of it. 
	console.log("Directory already there");
} else {

	fs.mkdir("dir_name", function(err) {

		if (err) {
			console.log(err);
		} else {
			console.log("Directory Created");
		}

	});

}

var fs = require("fs");


fs.renameSync("./lib/project-config.js", "./lib/config.json"); //synchronously

console.log("Config json file renamed");


//Moving a file 
fs.rename("./lib/notes.md", "./notes.md", function(err) { //asynchronously... Note: here we are moving notes.md to the parent directory of lib. 

	if (err) {
		console.log(err);
	} else {
		console.log("Notes.md moved successfully");
	}

});

var fs = require("fs");


/*
Here, I will do this synchronously, and we will remove from the library folder the config.json file. Again, because this is a synchronous request, if there were any problems with this request, it would automatically throw an error. If I don't want my code to throw an error, when making a synchronous request, I need to surround it in a try catch block. 

Note: throwing an error will make the process stop!
*/
try {
	fs.unlinkSync("./lib/config.json"); //synchronously
} catch (err) {
	console.log(err);
}

fs.unlink("notes.md", function(err) { //asynchronously 

	if (err) {
		console.log(err);
	} else {
		console.log("Notes.md removed");
    }
    
/*
So, what happens when I try to remove files that aren't there? Ig we run the code, we can see that we have two errors. Now, both of these errors are simply being logged to the console. They are not being thrown. When you throw an error, it will cause your program to crash.
*/    
});

var fs = require("fs"); 
fs.renameSync("./assets/logs", "./logs_new"); //moving and renaming logs directory

var fs = require("fs");

fs.readdirSync("./logs").forEach(function(fileName) { //READING ALL THE FILES FROM THE DIRECTORY AND LIST THEM (returns and array list). Then we are chaining a forEach method to that returned array list :) 
/*
So this will give me a list of those files. Now the neat thing is I could set a variable to all the files that are in that directory, but this is JavaScript, which means that we can also chain. So because this call returns an array I can simply chain on a .forEach, which is a JavaScript array function, that will take in a callback function that will be invoked once for every item inside of the array. Each file name will be passed to this callback function. So we are looping through all of the files that are found in the logs directory, and what I'm going to go ahead and do is unlink them.
*/
	fs.unlinkSync("./logs/" + fileName);

});

//NOTE: YOU CAN NOT REMOVE A DIRECTORY UNLESS IT IS EMPTY! SO YOU SHOULD FIRST REMOVE ALL THE FILES INSIDE THE DIRECTORY BEFORE REMOVING THE DIRECTORY 
fs.rmdir("./logs", function(err) {  //rmdir will remove a directory 

	if (err) {
		throw err; //throwing an error will cause our program to crash and our JavaScript thread will not continue processing anymore JavaScript,
	}

	console.log("Logs directory removed");

});

var fs = require("fs"); 
fs.readFile("./chat/log", "UTF-8", function(err, chatlog){ 
    console.log(`File Read ${chatlog.length}`); 
});
console.log('Reading File'); 

var fs = require("fs");

var stream = fs.createReadStream("./chat.log", "UTF-8");
//Great, so now, as opposed to waiting for the entire file to be read, we can use this stream to start receiving small chunks of data from this file.

var data = "";


stream.once("data", function() {
	console.log("\n\n\n");
	console.log("Started Reading File");
	console.log("\n\n\n");
});

stream.on("data", function(chunk) {
	process.stdout.write(`  chunk: ${chunk.length} |`);
	data += chunk;
}); 

stream.on("end", function() {
	console.log("\n\n\n");
	console.log(`Finished Reading File ${data.length}`);
	console.log("\n\n\n");
});

var readline = require('readline');
var rl = readline.createInterface(process.stdin, process.stdout);
var fs = require("fs");

var realPerson = {
	name: '',
	sayings: []
};


rl.question("What is the name of a real person? ", function(answer) {

	realPerson.name = answer;

	//
	//	TODO: Use a Writable Stream
	//
	fs.writeFileSync(realPerson.name + ".md", `${realPerson.name}\n==================\n\n`);

	rl.setPrompt(`What would ${realPerson.name} say? `);

	rl.prompt();

	rl.on('line', function(saying) {

		realPerson.sayings.push(saying.trim());

		//
		//TODO: Write to the stream
		//
		fs.appendFileSync(realPerson.name + ".md", `* ${saying.trim()} \n`);


		if (saying.toLowerCase().trim() === 'exit') {
			rl.close();
		} else {
			rl.setPrompt(`What else would ${realPerson.name} say? ('exit' to leave) `);
		    rl.prompt();
		}

	});

});


rl.on('close', function() {

	console.log("%s is a real person that says %j", realPerson.name, realPerson.sayings);
	process.exit();

});

var https = require("https");
var fs = require("fs");

var options = {
	hostname: "en.wikipedia.org",
	port: 443,
	path: "/wiki/George_Washington",
	method: "GET"
};

var req = https.request(options, function(res) {
    /*
    Once our request has started, this callback function, the second argument of the request function will be invoked. It will also add our response object. Now, I said "once the request has started", because our response object actually implements the stream interface. What we're going to do with this request is we are going to get George Washington's Wikipedia page sent to us from the Wikipedia server as a stream. The first thing I'm going to do is create a variable for the response body and we will set that to an empty stream.
    */

	var responseBody = "";

	console.log("Response from server started.");
	console.log(`Server Status: ${res.statusCode} `);
	console.log("Response Headers: %j", res.headers);

	res.setEncoding("UTF-8");

	res.once("data", function(chunk) { // Once we started receiving data (listener) we will console.log only the first chunk
		console.log(chunk);
	});

	res.on("data", function(chunk) { // For all the data received (for every data event) (listener) we will store every chunk of this data in the responseBody variable 
		console.log(`--chunk-- ${chunk.length}`);
		responseBody += chunk;
	});

	res.on("end", function() { // Once our response is over (listener) we will take the content fetched and create a file to put the received content 
		fs.writeFile("george-washington.html", responseBody, function(err) {
			if (err) {
				throw err;
			}
			console.log("File Downloaded");
		});
	});

});

req.on("error", function(err) { // We are listening for any occurence of an error and console.logging it 
	console.log(`problem with request: ${err.message}`);
});

req.end(); //we are ending the request 

var http = require("http");
/*
So I'm going to create a variable for my server instance, and I will use http.createServer to build this web server. Now, every time we make a request of our web server, the callback function that we add to create.Server will be invoked. So any request of our web server will cause this function to be invoked. What we are going to get with this function is the actual request object. This request object will contain information about the requested headers, any data that is going along with the request, as well as information about our user, like their environment and so on and so forth.

The other argument that we'll be adding here is going to be our response object. So, we will have a blank response object also sent to this request function, and it's going to be our job to complete the response. 
*/

var server = http.createServer(function(req, res) {

    /*
    We will do so by writing the response headers. So I'm going to use the response.writeHead method to complete our response headers. The first argument that we add to this method is going to be our response status code. 200 means that we have a successful response. The second argument represents a JavaScript literal of all the headers that I am going to add to this response.

The one header that I really want to add is "Content-Type", and this will tell the browser what type of content we are responding with. For this server, we're just going to respond with "text/html".
*/

    res.writeHead(200, {"Content-Type": "text/html"});
    
    /*
     And once we've written the response headers, the next thing that we want to do is end the response and send some data. Res.end can be used to end our response. 
     */

	res.end(`
		<!DOCTYPE html>
		<html>
			<head>
				<title>HTML Response</title>
			</head>
			<body>
				<h1>Serving HTML Text</h1>
				<p>${req.url}</p>
				<p>${req.method}</p>
			</body>
		</html>
	`);

});

server.listen(3000); //Finally we need to tell this server instance what IP and port it should be listening for incoming requests on.

//Server.listen is a function that we can use to specific the IP address and incoming port for all of our web requests for this server. I'm going to add (3000), telling this server to listen to any requests on this local machine for port 3000. 

console.log("Server listening on port 3000");

var http = require("http");
var fs = require("fs"); 
var path = require("path");

http.createServer(function(req, res) {

	console.log(`${req.method} request for ${req.url}`);

	if (req.url === "/") {
		fs.readFile(__dirname + "./public/index.html", "UTF-8", function(err, html) {
			res.writeHead(200, {"Content-Type": "text/html"});
			res.end(html);
		});
/*
So before writing the next code, I'm going to go over to the browser and open up a new browser window, and hit "http:localhost:3000", and when I do so, we can see that we are serving our html file. Now, if I go back to the terminal, one thing you'll notice is, making a request for this html file also makes a request for a stylesheet, also makes a request for a birds.jpg, and our browser is also making a request for a favorite icon icon file.

So, just requesting one html file has caused all these other requests to occur. The issue is, is that if we try to request our stylesheet, we don't get to see it. That's 404, because any request that is not our home page is giving us a 404 right now. That also includes birds.jpg. So, we need to improve our web server to also additionally serve these files.
*/
    } else if (req.url.match(/.css$/)) { //we can check if the requested url matches that regular expression    
    
    /*
    So, if we do have a file with a .css extension, we need to serve that file, too. Now, of course, I could just fs.readFile the way that I've done above, that's one way to do it, but remember, our problem with reading the files, we have to wait until the entire file is read, and then we're going to respond with the entire file. So, what would actually be a better solution is to create a ReadStream.
    */

		var cssPath = path.join(__dirname, 'public', req.url);
		var fileStream = fs.createReadStream(cssPath, "UTF-8");

        res.writeHead(200, {"Content-Type": "text/css"});
        
        /*
         And now, finally, once we have a ReadStream, we can actually pipe a ReadStream to a writable stream. Our response object is a writable stream, so what I'm going to actually do is use the fileStream and it has a pipe method.

         We can take a ReadStream and pipe it to a writable stream using this method .pipe(). So what this will do is it will actually stream the contents of our file to our response and it will automatically handle when that response is over and chunking the data and everything for us. So, this is great. This will actually send our .css file back. 
        */

		fileStream.pipe(res); //here we are piping our readstream: fileStream to a writable stream wich is res (our response itself is a writable stream)

	} else if (req.url.match(/.jpg$/)) {

		var imgPath = path.join(__dirname, 'public', req.url);
		var imgStream = fs.createReadStream(imgPath); //here we don't need to set to utf8, because we are reading the image as a binary 

		res.writeHead(200, {"Content-Type": "image/jpeg"});

		imgStream.pipe(res);

	} else {
		res.writeHead(404, {"Content-Type": "text/plain"});
		res.end("404 File Not Found");
	}

}).listen(3000);


console.log("File server running on port 3000");

[
  {
    "name": "K-Eco 180",
    "sku": "KE180",
    "cost": "$162.00",
    "retail": "$315.00",
    "avail": "In stock"
  },
  {
    "name": "K-Eco 200",
    "sku": "KE200",
    "cost": "$180.00",
    "retail": "$350.00",
    "avail": "In stock"
  },
  {
    "name": "K-Eco 225",
    "sku": "KE225",
    "cost": "$198.00",
    "retail": "$385.00",
    "avail": "On back order"
  },
  {
    "name": "K-Eco 250",
    "sku": "KE250",
    "cost": "$225.00",
    "retail": "$437.50",
    "avail": "In stock"
  }
]

var http = require("http");

var data = require("./data/inventory");

http.createServer(function(req, res) {

	if (req.url === "/") {
		res.writeHead(200, {"Content-Type": "text/json"});
	    res.end(JSON.stringify(data));
	} else if (req.url === "/instock") {
		listInStock(res);
	} else if (req.url === "/onorder") {
		listOnBackOrder(res);
	} else {
		res.writeHead(404, {"Content-Type": "text/plain"});
		res.end("Whoops... Data not found");
	}

	

}).listen(3000);

console.log("Server listening on port 3000");


function listInStock(res) {

	var inStock = data.filter(function(item) {
		return item.avail === "In stock";
    });

    res.end(JSON.stringify(inStock));
    
    /*
    . So, the data is an array, it has a filter function. We use the filter function to filter out those data objects in our array for specific details. So, this function will take in a callback function, and this callback function will be invoked once for every item in the data, so, once for every one of our inventory items.

    And now, this function is what we would refer to as a Predicate. It should only return a True or a False. If this function returns True, then we are going to add this data item to a new array. If it returns False, then we will skip adding this inventory to our new array. So, what we want to do is return a True or False, as to whether this inventory item should be added to the new array. So, what we're going to do, is, the inventory item itself, is going to be passed as an argument to the callback function inside of the filter function.

    What we want to do now, is, return either True or False. And, we're going to return whether or not the items available key is equal to In stock. So, for every item that has the availability marked In stock, those items will be added to this new array.

    */

}

function listOnBackOrder(res) {

	var onOrder = data.filter(function(item) {
		return item.avail === "On back order";
	});

	res.end(JSON.stringify(onOrder));

}

var http = require("http");
var fs = require("fs");

http.createServer(function(req, res) {

	if (req.method === "GET") {
		res.writeHead(200, {"Content-Type": "text/html"});
	    fs.createReadStream("./public/form.html", "UTF-8").pipe(res);
	} else if (req.method === "POST") {

		var body = "";

		req.on("data", function(chunk) {
			body += chunk;
		});

		req.on("end", function() {

			res.writeHead(200, {"Content-Type": "text/html"});

			res.end(`

				<!DOCTYPE html>
				<html>
					<head>
						<title>Form Results</title>
					</head>
					<body>
						<h1>Your Form Results</h1>
						<p>${body}</p>
					</body>
				</html>

			`);


		});


	}	

}).listen(3000);

console.log("Form server listening on port 3000");

$(document).ready(function () {

    $.getJSON('/dictionary-api', printTerms);
    $('form').submit(function (e) {
        e.preventDefault();
        $.post('/dictionary-api', {term: $('#term').val(), defined: $('#defined').val()}, printTerms);
        this.reset();
    });

});

function printTerms(terms) {
    $('body>dl').empty();
    $.each(terms, function () {
        $('<dt>').text(this.term).appendTo('body>dl');
        $('<dd>').text(this.defined).appendTo('body>dl');
    });
    $('dt').off('dblclick').dblclick(function() {
        $.ajax({
            url: '/dictionary-api/' + $(this).text(),
            type: 'DELETE',
            success: printTerms
        });
    });
}

var express = require("express");

var app = express();
/*
Node.js knows to go look in the Node Modules folder to find the Express package. Now the next thing I need to do is create an application instance, and I can use the Express function to do that. var app will be my app instance, and invoking the Express function will create a new instance of an Express application. So now that I have a new instance of an Express application, I can add middleware to this application. You can think of middleware as being customized plugins that we can use with Express to add functionality to our application.
*/

/*
I'm going to add a custom piece of middleware that I can use to log each request.
I will use the app.use function to do so. Now, what we add to the app.use function is actually a callback function that will be invoked. So whenever we have a request, the app will use our custom piece of middleware. So whenever we have our request, now the application will first use our middleware function, and then it will proceed on to the express.static middleware.
*/
/*
So, each piece of middleware is a function that has three arguments: the request, the response, and the next function that you will invoke once you are finished. So what we're doing here is we are adding some functionality to our pipeline. Meaning that whenever we have a request, that request is going to trickle down through all of these app uses statements, until we find and return a response. So I am just going to use this function to log details about the request before returning the response.
*/
app.use(function(req, res, next) {
	console.log(`${req.method} request for '${req.url}'`);
    next();
    /*
    Now after we log these details to our terminal, we want to still serve the request.

    Our requests are presently being served in the next piece of middleware under express.static. So in order to tell our application to move on to the next piece of middleware in the pipeline, we need to invoke this next function. If we do not invoke this next function, we will never send a response back, and our application will technically not work.
    */
});

/*
The piece of middleware that we want to use is a static file server that comes with Express. Express.static will invoke the static file server that comes with Express, and we're going to add it to our app pipeline as a piece of middleware. Now, this function needs to take in the name of the directory where we would like to serve static files from. That directory is ./public. So I add a path to the public directory there, and now if we are making requests for any static files that are found under that directory, they will get served.
*/


app.use(express.static("./public")); //express static middleware


app.listen(3000);

console.log("Express app running on port 3000");

/*
 And then the next thing that I'm going to do is just go ahead and also export my app module.

Now, you don't need to do this for this Express app to run, but it's always a good idea. If I export this application instance as a module, that means I can include this application instance in other files. Later on, we are going to be including this application in the files that we will use to test it, so it's not a bad idea to add that now. 
*/
module.exports = app;

var express = require("express");
var cors = require("cors");
var app = express();

var skierTerms = [
    {
        term: "Rip",
        defined: "To move at a high rate of speed"
    },
    {
        term: "Huck",
        defined: "To throw your body off of something, usually a natural feature like a cliff"
    },
    {
        term: "Chowder",
        defined: "Powder after it has been sufficiently skied"
    }
];


app.use(function(req, res, next) {
	console.log(`${req.method} request for '${req.url}'`);
	next();
});

app.use(express.static("./public"));

/*
Now, our dictionary api works great, but it has some limitations. The dictionary api, by default, is only allowed to serve this data to requests made for it from the same domain name. So our application works because our application is running on local host 3000 and our dictionary is also running on local host 3000. But what happens if our client application is running from skierdictionary.com and our dictionary api is running from skierterms.com? That means that this data, we would not be able to serve to a different domain name.

So we can only serve this data to the exact same domain. Now, we've already installed a module that will help us get around that.

Cors stands for "cross origin resource sharing," and this specific module is a piece of middleware that we can add to our Epress pipeline to solve this problem. 

Cors is a function and it's a function that will return some middleware. 
*/

app.use(cors()); //So, now we've added cross origin resource sharing to our application. This means that any domain can make a request for our dictionary api.

/*
The app.get function will set up a get route for me.

The first argument that it takes is the location for that route, so this is going to be at /dictionary-api. And the second argument is going to be the function that will actually handle any requests for that specific route. This function will take in our request object and our response object. Now these are the same request and response objects that we used with the http server, but they've been powered up by Express. Express has decorated these objects, has added some functionality to them to make things easy for us.

For instance, the response object now has a json function. In the response, json function will simply take a json object, like our skiier terms and automatically handle stringifying it, and setting up the headers to reply with a json response. 
*/
app.get("/dictionary-api", function(req, res) {
	res.json(skierTerms);
});

app.listen(3000);

console.log("Express app running on port 3000");

module.exports = app;

/*
The bodyParser is middleware that will help us parse the data that is posted to this API. So if we post data from my rest application, it will send data as .json. If we actually fill out a form in a web browser and POST the data, that data will be sent to us URL-encoded.

So we need to get in there and parse that POST data so that we can use those variables very neatly.
*/
var express = require("express");
var cors = require("cors");
var bodyParser = require("body-parser");
var app = express();

var skierTerms = [
    {
        term: "Rip",
        defined: "To move at a high rate of speed"
    },
    {
        term: "Huck",
        defined: "To throw your body off of something, usually a natural feature like a cliff"
    },
    {
        term: "Chowder",
        defined: "Powder after it has been sufficiently skied"
    }
];
/*
So I'm going to add an app.use to add the bodyParser and the first type of body that we want to parse are .json bodies. So if we have data sent to our API as .json, we will parse that data. And also we're going to use the bodyParser to make sure if the body data was sent URL-encoded that we are parsing that as well.
*/
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false })); // You will only need to set extended to true if you have large amounts of nested POST data to parse.

/*
So now that we've parsed this data, what happened? It just means that we have gone in and parsed all the variables that are posted to this application, and placed them neatly on the request object. 
*/

app.use(function(req, res, next) {
	console.log(`${req.method} request for '${req.url}' - ${JSON.stringify(req.body)}`);
	next();
});

app.use(express.static("./public"));

app.use(cors());

app.get("/dictionary-api", function(req, res) {
	res.json(skierTerms);
});

app.post("/dictionary-api", function(req, res) {
    skierTerms.push(req.body);
    res.json(skierTerms);
});

app.delete("/dictionary-api/:term", function(req, res) { // And right below my POST route I'm also going to add a DELETE route. And if you send a term to dictionary-api/ whatever term you send, I can set that up as a routing variable with a colon. So this means that I've just created a routing parameter called "term". The value of this variable will be whatever is found in the route after dictionary-api on a DELETE request.
    skierTerms = skierTerms.filter(function(definition) {
        return definition.term.toLowerCase() !== req.params.term.toLowerCase();
    });
    res.json(skierTerms);
});

app.listen(3000);

console.log("Express app running on port 3000");

module.exports = app;

//So at this point, our application seems to work. We can display dictionary terms, we can add new terms, and we can delete the terms. And our client app is getting these terms, posting these terms, and deleting these terms to our web server application via an API.

  "scripts": {
    "prestart": "grunt",
    "start": "node app",
    "predev": "grunt",
    "dev": "open http://localhost:3000 & node-dev app & grunt watch"
  },