/*

   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>

   Copyright (C) 2012-2013 Michael Möller <mmoeller@openhardwaremonitor.org>

 */

 using System;

 using System.Drawing;

 using System.Drawing.Imaging;

 using System.IO;

 using System.Net;

 using System.Reflection;

 using System.Text;

 using System.Threading;

 using OpenHardwareMonitor.GUI;

 using OpenHardwareMonitor.Hardware;

 namespace OpenHardwareMonitor.Utilities {

   public class HttpServer {

     private HttpListener listener;

     private int listenerPort, nodeCount;

     private Thread listenerThread;

     private Node root;

     public HttpServer(Node node, int port) {

       root = node;

       listenerPort = port;

       //JSON node count. 

       nodeCount = 0;

       try {

         listener = new HttpListener();

         listener.IgnoreWriteExceptions = true;

       } catch (PlatformNotSupportedException) {

         listener = null;

       }

     }

     public bool PlatformNotSupported {

       get {

         return listener == null;

       }

     }

     public Boolean StartHTTPListener() {

       if (PlatformNotSupported)

         return false;

       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) {

         return false;

       }

       return true;

     }

     public Boolean StopHTTPListener() {

       if (PlatformNotSupported)

         return false;

       try {

         listenerThread.Abort();

         listener.Stop();

         listenerThread = null;

       } catch (HttpListenerException) {

       } catch (ThreadAbortException) {

       } catch (NullReferenceException) {

       } catch (Exception) {

       }

       return true;

     }

     private void HandleRequests() {

       while (listener.IsListening) {

         var context = listener.BeginGetContext(

           new AsyncCallback(ListenerCallback), listener);

         context.AsyncWaitHandle.WaitOne();

       }

     }

     private void ListenerCallback(IAsyncResult result) {

       HttpListener listener = (HttpListener)result.AsyncState;

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

         return;

       // Call EndGetContext to complete the asynchronous operation.

       HttpListenerContext context;

       try {

         context = listener.EndGetContext(result);     

       } catch (Exception) {

         return;

       }

       HttpListenerRequest request = context.Request;

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

       if (requestedFile == "data.json") {

         SendJSON(context.Response);

         return;

       }

       if (requestedFile.Contains("images_icon")) {

         ServeResourceImage(context.Response, 

           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.Response, 

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

     }

     private void ServeResourceFile(HttpListenerResponse response, string name, 

       string ext) 

     {

       // 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])) {

             response.ContentType = GetcontentType("." + ext);

             response.ContentLength64 = stream.Length;

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

             int len;

             try {

               Stream output = response.OutputStream;

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

                 output.Write(buffer, 0, len);

               }

               output.Flush();

               output.Close();              

               response.Close();

             } catch (HttpListenerException) { 

             } catch (InvalidOperationException) { 

             }

             return;

           }          

         }

       }

       response.StatusCode = 404;

       response.Close();

     }

     private void ServeResourceImage(HttpListenerResponse response, 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);

             response.ContentType = "image/png";

             try {

               Stream output = response.OutputStream;

               using (MemoryStream ms = new MemoryStream()) {

                 image.Save(ms, ImageFormat.Png);

                 ms.WriteTo(output);

               }

               output.Close();

             } catch (HttpListenerException) {              

             }

             image.Dispose();

             response.Close();

             return;

           }

         }

       }

       response.StatusCode = 404;

       response.Close();

     }

     private void SendJSON(HttpListenerResponse response) {

       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);

       response.AddHeader("Cache-Control", "no-cache");

       response.ContentLength64 = buffer.Length;

       response.ContentType = "application/json";

       try {

         Stream output = response.OutputStream;

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

         output.Close();

       } catch (HttpListenerException) {

       }

       response.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() {

       if (PlatformNotSupported)

         return;

       StopHTTPListener();

       listener.Abort();

     }

     public void Quit() {

       if (PlatformNotSupported)

         return;

       StopHTTPListener();

       listener.Abort();

     }

   }

 }