using Newtonsoft.Json;
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using MqttMsgServer.HttpService.dto;
using ConsoleHttp.Model;
using MqttMsgServer.Dao;
using MqttMsgServer.Model;
using MqttMsgServer.Service.Client;
using MqttMsgServer.Tools;

namespace MqttMsgServer.HttpService
{
    public class HttpProcessor
    {
        public TcpClient Socket;
        public HttpServer Srv;
        private Stream _inputStream;
        public StreamWriter OutputStream;

        public string HttpMethod;
        public string HttpUrl;
        public string HttpProtocolVersionsString;
        public Hashtable HttpHeaders = new Hashtable();

        private static int MAX_POST_SIZE = 10 * 1024 * 1024;//10M

        public HttpProcessor(TcpClient s, HttpServer srv)
        {
            this.Socket = s;
            this.Srv = srv;
        }

        private string StreamReadLine(Stream inputStream)
        {
            string data = "";
            while (true)
            {
                var nextChar = inputStream.ReadByte();
                if (nextChar == '\n') { break; }
                if (nextChar == '\r') { continue; }

                if (nextChar == -1)
                {
                    Thread.Sleep(1);
                    continue;

                }

                data += Convert.ToChar(nextChar);
            }

            return data;
        }

        public void Process()
        {
            _inputStream = new BufferedStream(Socket.GetStream());
            OutputStream = new StreamWriter(new BufferedStream(Socket.GetStream()));
            try
            {
                ParseRequest();
                ReadHeaders();
                if (HttpMethod.Equals("GET"))
                {
                    HandleGetRequest();
                }
                else if (HttpMethod.Equals("POST"))
                {
                    HandlePostRequest();
                }
            }
            catch (Exception e)
            {
               //Console.WriteLine("Exception: " + e.ToString());
               this.LogDebug("Exception: " + e.ToString());
                WriteFailure();
            }
            OutputStream.Flush();
            // bs.Flush(); // flush any remaining output
            _inputStream = null; OutputStream = null; // bs = null;            
            Socket.Close();
        }

        public void ParseRequest()
        {
            string request = StreamReadLine(_inputStream);
            string[] tokens = request.Split(' ');
            if (tokens.Length != 3)
            {
                throw new Exception("invalid http request  line!");
            }

            HttpMethod = tokens[0].ToUpper();
            HttpUrl = tokens[1];
            HttpProtocolVersionsString = tokens[2];
           // Console.WriteLine("starting:" + request);
           this.LogDebug("starting:" + request);
        }

        public void ReadHeaders()
        {
          //  Console.WriteLine("readHeaders()");
          this.LogDebug("readHeaders()");
            string line;
            while ((line = StreamReadLine(_inputStream)) != null)
            {
                if (line.Equals(""))
                {
                   // Console.WriteLine("got  headers");
                   this.LogDebug("got  headers");
                   return;
                }

                int separator = line.IndexOf(':');
                if (separator == -1)
                {
                    throw new Exception("invalid http header line:" + line);
                }

                string name = line.Substring(0, separator);
                int pos = separator + 1;
                while ((pos < line.Length) && (line[pos] == ' '))
                {
                    pos++;
                }
                string value = line.Substring(pos, line.Length - pos);
                //Console.WriteLine("header: {0}:{1}", name, value);
                this.LogDebug($"header: {name}:{value}");
                HttpHeaders[name.ToLower()] = value;
            }
        }

        public void HandleGetRequest()
        {
            Srv.HandleGetRequest(this);
        }

        private const int BUF_SIZE = 4096;
        public void HandlePostRequest()
        {
            // this post data processing just reads everything into a memory stream.
            // this is fine for smallish things, but for large stuff we should really
            // hand an input stream to the request processor. However, the input stream 
            // we hand him needs to let him see the "end of the stream" at this content 
            // length, because otherwise he won't know when he's seen it all! 

           // Console.WriteLine("get post data start");
           this.LogDebug("get post data start");
            int content_len = 0;
            MemoryStream ms = new MemoryStream();
            if (this.HttpHeaders.ContainsKey("Content-Length".ToLower()))
            {
                content_len = Convert.ToInt32(this.HttpHeaders["Content-Length".ToLower()]);
                if (content_len > MAX_POST_SIZE)
                {
                    throw new Exception(
                        $"POST Content-Length({content_len}) too big for this simple server");
                }
                byte[] buf = new byte[BUF_SIZE];
                int to_read = content_len;
                while (to_read > 0)
                {
                    //Console.WriteLine("starting Read, to_read={0}", to_read);
                    this.LogDebug($"starting Read, to_read={to_read}");
                    int numread = this._inputStream.Read(buf, 0, Math.Min(BUF_SIZE, to_read));
                    //Console.WriteLine("read finished, numread={0}", numread);
                    this.LogDebug($"read finished, numread={numread}" );
                    if (numread == 0)
                    {
                        if (to_read == 0)
                        {
                            break;
                        }
                        throw new Exception("client disconnected during post");
                    }
                    to_read -= numread;
                    ms.Write(buf, 0, numread);
                }
                ms.Seek(0, SeekOrigin.Begin);
            }
            //Console.WriteLine("get post data end");
            this.LogDebug("get post data end");
            Srv.HandlePostRequest(this, new StreamReader(ms));

        }

        public void WriteSuccess(string type = "")
        {
            OutputStream.WriteLine("HTTP/1.0 200 OK");
            switch (type)
            {
                case "json":
                    OutputStream.WriteLine("Content-Type: application/json; charset=UTF-8");
                    break;
                default:
                    OutputStream.WriteLine("Content-Type: text/html;charset=utf-8");
                    break;
            }
            OutputStream.WriteLine("Connection: close");
            OutputStream.WriteLine("");
        }

        public void WriteFailure()
        {
            OutputStream.WriteLine("HTTP/1.0 404 File not found");
            OutputStream.WriteLine("Connection: close");
            OutputStream.WriteLine("");
        }

    }

    public abstract class HttpServer
    {
        protected int Port;
        private TcpListener _listener;
        private bool _isActive = true;

        public HttpServer(int port)
        {
            this.Port = port;
        }

        [Obsolete]
        public void Listen()
        {
            _listener = new TcpListener(Port);

            _listener.Start();
            while (_isActive)
            {
                try
                {
                    TcpClient s = _listener.AcceptTcpClient();
                    HttpProcessor processor = new HttpProcessor(s, this);
                    Thread thread = new Thread(processor.Process);
                    thread.Start();
                    Thread.Sleep(1);
                }
                catch (Exception e)
                {
                   this.LogError(e.Message);
                }
               
            }
        }
        public abstract void HandleGetRequest(HttpProcessor p);
        public abstract void HandlePostRequest(HttpProcessor p, StreamReader inputData);
    }

    public class MyHttpServer : HttpServer
    {
        public MyHttpServer(int port) : base(port)
        {

        }
        public override void HandleGetRequest(HttpProcessor p)
        {
            //Console.WriteLine("request: {0}", p.HttpUrl);
            this.LogDebug($"request--Get:{p.HttpUrl}");
            p.WriteSuccess();
            string response = "{\"url\":\""+p.HttpUrl+"\"}";
            p.OutputStream.WriteLine(response);


            //p.outputStream.WriteLine("<html><body><h1>test server</h1>");
            //p.outputStream.WriteLine("Current Time: " + DateTime.Now.ToString());
            //p.outputStream.WriteLine("url : {0}", p.http_url);
            //
            //p.outputStream.WriteLine("<form method=post action=/form>");
            //p.outputStream.WriteLine("<input type=text name=foo value=foovalue>");
            //p.outputStream.WriteLine("<input type=submit name=bar value=barvalue>");
            //p.outputStream.WriteLine("</form>");
        }

        public override void HandlePostRequest(HttpProcessor p, StreamReader inputData)
        {
           
            ResponseResult result = new ResponseResult();
            try
            {
                // Console.WriteLine("POST request: {0}", p.HttpUrl);
                this.LogDebug($"request--Post:{p.HttpUrl}");
                string data = inputData.ReadToEnd();
                this.LogError("请求:===" + data);
                if (string.IsNullOrEmpty(data))
                {
                    p.OutputStream.WriteLine("{\"result\":\"参数为空！\"}");
                }
                p.WriteSuccess("json");
             
                if (!p.HttpUrl.EndsWith("regClient"))
                {
                    p.OutputStream.WriteLine("{\"result\":\"404\"}");
                }

                var clientDto = JsonConvert.DeserializeObject<ClientDto>(data);
                ClientInfoService cs = new ClientInfoService();
                result = cs.AddOrUpdateClient(clientDto);
                p.OutputStream.WriteLine(JsonConvert.SerializeObject(result));
            }
            catch (Exception e)
            {
                result.IsSuccess = false;
                result.ErrorMessage = e.Message;
                this.LogError(e.StackTrace);
                p.OutputStream.WriteLine(JsonConvert.SerializeObject(result));
            }




        }
    }
}