/*

   This Source Code Form is subject to the terms of the Mozilla Public

   License, v. 2.0. If a copy of the MPL was not distributed with this

   file, You can obtain one at http://mozilla.org/MPL/2.0/.

 	Copyright (C) 2012 Prince Samuel <prince.samuel@gmail.com>

 */

 using System;

 using System.Collections.Generic;

 using System.Text;

 using System.Net;

 using System.Threading;

 using System.IO;

 using OpenHardwareMonitor.GUI;

 using OpenHardwareMonitor.Hardware;

 using System.Reflection;

 using System.Drawing;

 using System.Drawing.Imaging;

 namespace OpenHardwareMonitor.Utilities

 {

     public class HttpServer

     {

         private HttpListener listener;

         private int listenerPort, nodeCount;

         private Thread listenerThread;

         private Node root;

         public HttpServer(Node r, int p)

         {

             root = r;

             listenerPort = p;

             //JSON node count. 

             nodeCount = 0;

             listener = new HttpListener();

         }

         public Boolean startHTTPListener()

         {

             try

             {

                 if (listener.IsListening)

                     return true;

                 string prefix = "http://+:" + listenerPort + "/";

                 listener.Prefixes.Clear();

                 listener.Prefixes.Add(prefix);

                 listener.Start();

                 if (listenerThread == null)

                 {

                     listenerThread = new Thread(HandleRequests);

                     listenerThread.Start();

                 }

             }

             catch (Exception e)

             {

                 return false;

             }

             return true;

         }

         public Boolean stopHTTPListener()

         {

             try

             {

                 listenerThread.Abort();

                 listener.Stop();

                 listenerThread = null;

             }

             catch (System.Net.HttpListenerException e)

             {

             }

             catch (System.Threading.ThreadAbortException e)

             {

             }

             catch (System.NullReferenceException e)

             {

             }

             catch (Exception e)

             {

             }

             return true;

         }

         public void HandleRequests()

         {

             while (listener.IsListening)

             {

                 var context = listener.BeginGetContext(new AsyncCallback(ListenerCallback), listener);

                 context.AsyncWaitHandle.WaitOne();

             }

         }

         public void ListenerCallback(IAsyncResult result)

         {

             HttpListener listener = (HttpListener)result.AsyncState;

             if (listener == null || !listener.IsListening)

                 return;

             // Call EndGetContext to complete the asynchronous operation.

             HttpListenerContext context = listener.EndGetContext(result);

             HttpListenerRequest request = context.Request;

             var requestedFile = request.RawUrl.Substring(1);

             if (requestedFile == "data.json")

             {

                 sendJSON(context);

                 return;

             }

             if (requestedFile.Contains("images_icon"))

             {

                 serveResourceImage(context, requestedFile.Replace("images_icon/", ""));

                 return;

             }

             //default file to be served

             if (string.IsNullOrEmpty(requestedFile))

                 requestedFile = "index.html";

             string[] splits = requestedFile.Split('.');

             string ext = splits[splits.Length - 1];

             serveResourceFile(context, "Web." + requestedFile.Replace('/', '.'), ext);

         }

         private void serveResourceFile(HttpListenerContext context ,string name, string ext) {

           //hack! resource names do not support the hyphen

           name = "OpenHardwareMonitor.Resources." + name.Replace("custom-theme", "custom_theme");

           string[] names = 

             Assembly.GetExecutingAssembly().GetManifestResourceNames();

           for (int i = 0; i < names.Length; i++) {

             if (names[i].Replace('\\', '.') == name) {

               using (Stream stream = Assembly.GetExecutingAssembly().

                 GetManifestResourceStream(names[i])) {

                     context.Response.ContentType = getcontentType("." + ext);

                     context.Response.ContentLength64 = stream.Length;

                     byte[] buffer = new byte[512 * 1024];

                     int len;

                     while ((len = stream.Read(buffer, 0, buffer.Length)) > 0)

                     {

                         context.Response.OutputStream.Write(buffer, 0, len);

                     }

                     context.Response.OutputStream.Close();

                 }

               return;

             }

           }

           context.Response.OutputStream.Close();

           context.Response.StatusCode = 404;

           context.Response.Close();

         }

         private void serveResourceImage(HttpListenerContext context ,string name) {

           name = "OpenHardwareMonitor.Resources." + name;

           string[] names = 

             Assembly.GetExecutingAssembly().GetManifestResourceNames();

           for (int i = 0; i < names.Length; i++) {

             if (names[i].Replace('\\', '.') == name) {

               using (Stream stream = Assembly.GetExecutingAssembly().

                 GetManifestResourceStream(names[i])) {

                 Image image = Image.FromStream(stream);

                 context.Response.ContentType = "image/png";

                 using (MemoryStream ms = new MemoryStream())

                 {

                     image.Save(ms, ImageFormat.Png);

                     ms.WriteTo(context.Response.OutputStream);

                 }

                 context.Response.OutputStream.Close();

                 image.Dispose();

                 return;

               }

             }

           } 

           context.Response.OutputStream.Close();

           context.Response.StatusCode = 404;

           context.Response.Close();

         }

         private void sendJSON(HttpListenerContext context)

         {

             string JSON = "{\"id\": 0, \"Text\": \"Sensor\", \"Children\": [";

             nodeCount = 1;

             JSON += generateJSON(root);

             JSON += "]";

             JSON += ", \"Min\": \"Min\"";

             JSON += ", \"Value\": \"Value\"";

             JSON += ", \"Max\": \"Max\"";

             JSON += ", \"ImageURL\": \"\"";

             JSON += "}";

             var responseContent = JSON;

             byte[] buffer = Encoding.UTF8.GetBytes(responseContent);

             context.Response.ContentLength64 = buffer.Length;

             context.Response.ContentType = "application/json";

             Stream outputStream = context.Response.OutputStream;

             outputStream.Write(buffer, 0, buffer.Length);

             outputStream.Close();

         }

         private string generateJSON(Node n)

         {

             string JSON = "{\"id\": " + nodeCount + ", \"Text\": \"" + n.Text + "\", \"Children\": [";

             nodeCount++;

             foreach (Node child in n.Nodes)

                 JSON += generateJSON(child) + ", ";

             if (JSON.EndsWith(", "))

                 JSON = JSON.Remove(JSON.LastIndexOf(","));

             JSON += "]";

             if (n is SensorNode)

             {

                 JSON += ", \"Min\": \"" + ((SensorNode)n).Min + "\"";

                 JSON += ", \"Value\": \"" + ((SensorNode)n).Value + "\"";

                 JSON += ", \"Max\": \"" + ((SensorNode)n).Max + "\"";

                 JSON += ", \"ImageURL\": \"images/transparent.png\"";

             }

             else if (n is HardwareNode)

             {

                 JSON += ", \"Min\": \"\"";

                 JSON += ", \"Value\": \"\"";

                 JSON += ", \"Max\": \"\"";

                 JSON += ", \"ImageURL\": \"images_icon/" + getHardwareImageFile((HardwareNode)n) + "\"";

             }

             else if (n is TypeNode)

             {

                 JSON += ", \"Min\": \"\"";

                 JSON += ", \"Value\": \"\"";

                 JSON += ", \"Max\": \"\"";

                 JSON += ", \"ImageURL\": \"images_icon/" + getTypeImageFile((TypeNode)n) + "\"";

             }

             else

             {

                 JSON += ", \"Min\": \"\"";

                 JSON += ", \"Value\": \"\"";

                 JSON += ", \"Max\": \"\"";

                 JSON += ", \"ImageURL\": \"images_icon/computer.png\"";

             }

             JSON += "}";

             return JSON;

         }

         private static void returnFile(HttpListenerContext context, string filePath)

         {

             context.Response.ContentType = getcontentType(Path.GetExtension(filePath));

             const int bufferSize = 1024 * 512; //512KB

             var buffer = new byte[bufferSize];

             using (var fs = File.OpenRead(filePath))

             {

                 context.Response.ContentLength64 = fs.Length;

                 int read;

                 while ((read = fs.Read(buffer, 0, buffer.Length)) > 0)

                     context.Response.OutputStream.Write(buffer, 0, read);

             }

             context.Response.OutputStream.Close();

         }

         private static string getcontentType(string extension)

         {

             switch (extension)

             {

                 case ".avi": return "video/x-msvideo";

                 case ".css": return "text/css";

                 case ".doc": return "application/msword";

                 case ".gif": return "image/gif";

                 case ".htm":

                 case ".html": return "text/html";

                 case ".jpg":

                 case ".jpeg": return "image/jpeg";

                 case ".js": return "application/x-javascript";

                 case ".mp3": return "audio/mpeg";

                 case ".png": return "image/png";

                 case ".pdf": return "application/pdf";

                 case ".ppt": return "application/vnd.ms-powerpoint";

                 case ".zip": return "application/zip";

                 case ".txt": return "text/plain";

                 default: return "application/octet-stream";

             }

         }

         private static string getHardwareImageFile(HardwareNode hn)

         {

             switch (hn.Hardware.HardwareType)

             {

                 case HardwareType.CPU:

                     return "cpu.png";

                 case HardwareType.GpuNvidia:

                     return "nvidia.png";

                 case HardwareType.GpuAti:

                     return "ati.png";

                 case HardwareType.HDD:

                     return "hdd.png";

                 case HardwareType.Heatmaster:

                     return "bigng.png";

                 case HardwareType.Mainboard:

                     return "mainboard.png";

                 case HardwareType.SuperIO:

                     return "chip.png";

                 case HardwareType.TBalancer:

                     return "bigng.png";

                 case HardwareType.RAM:

                     return "ram.png";

                 default:

                     return "cpu.png";

             }

         }

         private static string getTypeImageFile(TypeNode tn)

         {

             switch (tn.SensorType)

             {

                 case SensorType.Voltage:

                     return "voltage.png";

                 case SensorType.Clock:

                     return "clock.png";

                 case SensorType.Load:

                     return "load.png";

                 case SensorType.Temperature:

                     return "temperature.png";

                 case SensorType.Fan:

                     return "fan.png";

                 case SensorType.Flow:

                     return "flow.png";

                 case SensorType.Control:

                     return "control.png";

                 case SensorType.Level:

                     return "level.png";

                 case SensorType.Power:

                     return "power.png";

                 default:

                     return "power.png";

             }

         }

         public int ListenerPort

         {

             get { return listenerPort; }

             set { listenerPort = value; }

         }

         ~HttpServer()

         {

             stopHTTPListener();

             listener.Abort();

         }

         public void Quit()

         {

             stopHTTPListener();

             listener.Abort();

         }

     }

 }