using System;
using Newtonsoft.Json;
using System.IO;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Net.Http.Headers;
using System.Net.Http;
using System.Text;
using System.Threading;
using Newtonsoft.Json.Bson;
using System.Collections;
using System.Net;
using System.Data;
using System.Xml;
using System.Xml.Serialization;
using System.Diagnostics;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System.Security.Policy;

namespace OnDocScriptGraphQL
{
    public class OnDocScriptGraphQL
    {
        public string rstring { get; set; }
        public string sourcequery { get; set; } = "";
        public DataTable resultdatatable { get; set; } = new DataTable();
        public string resultstring { get; set; } = "";
        private string uri = "";
        private string query = "";
        private string queryresult = "";

        public class ql
        {
            public string jsonstring { get; set; }
            public string error { get; set; }
        }
        public ql qldata = new ql();

        public class resultdata
        {
            public string name { get; set; }
            public string value { get; set; }

            public resultdata(string name, string value)
            {
                this.name = name;
                this.value = value;
            }
        }

        public class TableColumns
        {
            public string columnname { get; set; }
            public string columntitle { get; set; }
            public TableColumns(string columnname, string columntitle)
            {
                this.columnname = columnname;
                this.columntitle = columntitle;
            }
        }
      
        List<resultdata> QLRESULTS = new List<resultdata>();
        string qlqueryreslt = "";

        private string ParseJson(JToken token)
        {

            switch (token.Type)
            {
                case JTokenType.Object:
                    foreach (var property in (JObject)token)
                    {
                        if (queryresult.Contains(property.Key)) { QLRESULTS.Add(new resultdata(property.Key.ToString(), property.Value.ToString())); }
                        ParseJson(property.Value);
                    }
                    break;

                case JTokenType.Array:
                    foreach (var item in (JArray)token)
                    {
                        ParseJson(item);
                    }
                    break;

                default:
                    break;
            }
            return "";
        }
        string[] StringSplit(string StringToSplit, string Delimitator)
        {
            return StringToSplit.Split(new[] { Delimitator }, StringSplitOptions.None);
        }
       
        public async Task rungraphql(string iquery, string partnernr)
        {
            bool singlestring=false;
            query = "";
            iquery = iquery.Replace("&OnDocGraphQL", "");
            string[] graphgraphlines = StringSplit(iquery, Environment.NewLine);
            foreach (string line in graphgraphlines)
            {
                if (line.Contains("URI="))
                {
                    uri = line.Replace("URI=", "");
                }
                else
                {
                    if (line.Contains("QUERYResult="))
                    {
                        queryresult = line.Replace("QUERYResult=", "");
                    }
                    else
                    {
                        query = query + line;
                    }
                }

            }
            if (queryresult.Contains("SingleString"))
            {
                singlestring = true;
                queryresult = queryresult.Replace("SingleString:", "");
            }
            query = query.Replace("QUERY=", "");
            query = query.Replace("Type:GraphQL", "");
            query = query.Replace("&&Partnernr&&", partnernr);

            await run(uri, query);
            string result = qldata.jsonstring;

            string[] cols = queryresult.Split(',');
            List<TableColumns> columns = new List<TableColumns>();
            DataTable dt = new DataTable();

            foreach (string col in cols)
            {
                string[] column = col.Split('@');
                if (column.Length > 1)
                {
                    columns.Add(new TableColumns(column[0], column[1]));
                }
                else
                {
                    columns.Add(new TableColumns(column[0], column[0]));
                }
            }

            foreach (TableColumns t in columns)
            {
                dt.Columns.Add(t.columntitle);
            }


            dynamic data = JObject.Parse(result);
            //qlqueryreslt = data;
            ParseJson(data);
            string firstcol = cols[0];
            int ii = 0;
            DataRow dr = dt.NewRow();
            this.resultstring = "";
            foreach (resultdata item in QLRESULTS)
            {
                if (queryresult.Contains(item.name))
                {
                    if (item.name == columns[0].columnname)
                    {
                        dr[columns[0].columntitle] = item.value.ToString();
                        if (ii > 0)
                        {
                            dt.Rows.Add(dr);
                            dr = dt.NewRow();
                        }

                        dr[columns[0].columntitle] = item.value.ToString();
                    }
                    else
                    {
                        foreach (TableColumns col in columns)
                        {
                            if (col.columnname == item.name)
                            {
                                dr[col.columntitle] = item.value;
                            }

                            //dr[item.name] = item.value.ToString();
                        }
                    }
                    ii++;
                }

            }
            dt.Rows.Add(dr);
            dt.AcceptChanges();
            if (singlestring)
            {
                this.resultstring = dt.Rows[0][0].ToString();
            }
            else
            {
                this.resultdatatable = dt.Copy();
            }
            dt = null;
            return;
         
        }
        public async Task run(string uri, string query)
        {
            var result = await CallGraphQLAsync(
                    new Uri(uri),
                    HttpMethod.Post,
                    query, null
                    //,
                    //     new
                    //     {
                    //         city = "detroit",
                    //     }
                    );

            //return rstring;
            qldata.jsonstring = result;

        }
        private async void Graph2()
        {
            //var result = await CallGraphQLAsync<Data>(
            //       new Uri("https://spacex-production.up.railway.app//"),
            //       HttpMethod.Post,
            //       "query Ships { ships { id name }}", null
            //       //,
            //       //     new
            //       //     {
            //       //         city = "detroit",
            //       //     }
            //       );

            // jsonstring = rstring;


        }
        //private static async Task<GraphQLResponse<TResponse>> CallGraphQLAsync<TResponse>(Uri endpoint, HttpMethod method, string query, object variables)

        public string ToXml(DataSet ds)
        {
            using (var memoryStream = new MemoryStream())
            {
                using (TextWriter streamWriter = new StreamWriter(memoryStream))
                {
                    var xmlSerializer = new XmlSerializer(typeof(DataSet));
                    xmlSerializer.Serialize(streamWriter, ds);
                    return Encoding.UTF8.GetString(memoryStream.ToArray());
                }
            }
        }
        private async Task<string> CallGraphQLAsync(Uri endpoint, HttpMethod method, string query, object variables)
        {
            string url = endpoint.ToString();
            string qur = query;
            var requestBody = new
            {
                query = query
            };
            string jsonContent = Newtonsoft.Json.JsonConvert.SerializeObject(requestBody);

            using (var client = new HttpClient())
            {
                var content = new StringContent(jsonContent, Encoding.UTF8, "application/json");
                var cts = new CancellationTokenSource();
                cts.CancelAfter(3000); // 3 seconds

                HttpResponseMessage response = await client.PostAsync(url, content, cts.Token);

                if (response.IsSuccessStatusCode)
                {
                    string result = await response.Content.ReadAsStringAsync();
                    qldata.jsonstring = result;
                    result = qldata.jsonstring;
                    //var dataset = ReadDataFromJson(qldata.jsonstring, XmlReadMode.InferTypedSchema);
                    //result = ToXml(dataset);

                    return result;
                }
                else
                {
                    return ($"Fehler: {response.StatusCode}");
                }
            }
        }
        private static DataSet ReadDataFromJson(string jsonString, XmlReadMode mode = XmlReadMode.Auto)
        {
            //// Note:Json convertor needs a json with one node as root
            jsonString = $"{{ \"rootNode\": {{{jsonString.Trim().TrimStart('{').TrimEnd('}')}}} }}";
            //// Now it is secure that we have always a Json with one node as root 
            var xd = JsonConvert.DeserializeXmlNode(jsonString);

            //// DataSet is able to read from XML and return a proper DataSet
            var result = new DataSet();
            result.ReadXml(new XmlNodeReader(xd), mode);
            return result;
        }
        private async Task<string> CallGraphQLAsync1(Uri endpoint, HttpMethod method, string query, object variables)
        {
            var content = new StringContent(SerializeGraphQLCall(query, variables), Encoding.UTF8, "application/json");
            var httpRequestMessage = new HttpRequestMessage
            {
                Method = method,
                Content = content,
                RequestUri = endpoint,
            };
            //add authorization headers if necessary here
            try
            {
                httpRequestMessage.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
            }
            catch (Exception ex)
            {
                string a = ex.Message; ;
            }
            try
            {

                using (var response = await _httpClient.SendAsync(httpRequestMessage).ConfigureAwait(true))
                {
                    //if (response.IsSuccessStatusCode)
                    if (response?.Content.Headers.ContentType?.MediaType == "application/json")
                    {
                        var responseString = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
                        qldata.jsonstring = responseString;
                        return responseString;


                    }
                    else
                    {
                        throw new ApplicationException($"Unable to contact '{endpoint}': {response.StatusCode} - {response.ReasonPhrase}");
                    }
                }
            }
            catch (Exception e) { string b = e.Message; return ""; }
        }
        private string SerializeGraphQLCall(string query, object variables)
        {
            var sb = new StringBuilder();
            var textWriter = new StringWriter(sb);
            var serializer = new Newtonsoft.Json.JsonSerializer();
            serializer.Serialize(textWriter, new
            {
                query = query,
                variables = variables,
            });
            return sb.ToString();
        }



        private readonly HttpClient _httpClient = new HttpClient();
    }

}