using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
//using Newtonsoft.Json;
using System.Text.RegularExpressions;
using System.Threading;

namespace SampleCSharp
{
public unsafe delegate int FT_RTCallBack(void*PUser ,//When the function is called, the parameter pointer passed in by the caller
Int iQueryID ,//When the function is called, it is returned to the caller to indicate the ID of this request
char*PResultsBuff ,//Results returned by data query, in JSON format
Int iBuffLength ,//the length of the result cache
Int ErrorCode ,//error code
Int Reserved//Reserved
);
    class Program
    {
        /*
*E:\\ THSDataInterface _ Windows\\ bin\\ x86\\: This directory is the user's local data interface installation directory and the repaired bits are 32 bits. If it is 64 bits, the directory is E:\\ THSDataInterface _ Windows\\ bin\\ x64\\
*FTDataInterface.dll is the interface file, which is 32 bits, if it is 64 bits, the file name is FTDataInterface _ x64.dll
         */

        public const int REG_OPER_UPDATE = 0x01;
        public const int REG_OPER_ADD = 0x02;
        public const int REG_OPER_DEL = 0x03;


        //Modify the following path to the local data interface installation package path; if it is 64 bits, the directory is E:\\THSDataInterface_Windows\\bin\\x64\\，file name is FTDataInterface_x64.dll
        const string strPath = @"E:\\THSDataInterface_Windows\\bin\\x86\\";
        const string strDllFileName = "FTDataInterface.dll";        
        const string strDllFile = strPath + strDllFileName;

        static void Main(string[] args)
        {
            /*Login function, fill in account number and password
             */
            string strUserName = "account";
            string strPassWord = "password";
            int nRet = THS_iFinDLogin(strUserName, strPassWord);
            string strOut = "Login result:" + nRet;
            Console.WriteLine(strOut);
            Thread.Sleep(3000);

            _event = new AutoResetEvent(false);
            ThreadStart threadStart = new ThreadStart(testSample);
            Thread thread = new Thread(threadStart);
            thread.Start();
            _event.WaitOne();

            //Logout function
            //nRet = THS_iFinDLogout();
            //strOut = "Logout result:" + nRet;
            //Console.WriteLine(strOut);

            Console.ReadLine();
        }

        private static AutoResetEvent _event;
        public static void testSample()
        {
            //High frequency sequence function
            //HighFrequenceSequenceSample();

            //Real-time market function
            //RealtimeQuotesSample();

            //Historical market function
            //HistoryQuotesSample();

            //Basic data functions
            //BasicDataSample();

            //Date sequence function
            //DateSequenceSample();

            //Data pool function
            //DataPoolSample();
			
			//Thematic report function
            //DataReport();

            //EDB data request function
            //EDBQuerySample();

            //Intraday snapshot
            //Snapshot();

            //Data usage statistics function
            //DataStatisticsSample();

            //Error message query function
            //GetErrorInfoSample();

            //New date query function
            //DateQuerySample();

            //New date offset function
            //DateOffsetSample();

            //Date Statistics Function
            //DateCountSample();

            //Thread.Sleep(6000);
            //_event.Set();

        }

        static void HighFrequenceSequenceSample()
        {
            string strOut;
            //Request high frequency data to pass 5 string parameters and return data
/*The high-frequency sequence function format is THS _ HighFrequenceSequence (' thsCodes', 'indicators', 'params', 'startTime', 'endTime ')
*ThsCodes cannot be null and supports multiple inputs. When there are multiple thsCodes, they are separated by English half-width commas, such as thsCode 1, thsCode 2, thsCode 3
*Indicators cannot be null and support multiple inputs. When there are multiple indicators, they are separated by English semi-semicolons, such as indicator 1; indicator 2; indicator 3
*Params cannot be null and supports multiple inputs. When using default parameters, it can be represented by 'default'. When the user only sets one of the indicators and the other parameters remain default, only the set parameters need to be entered, such as' Interval: 5'
*The date input format for startDate is YYYY-MM-DD HH: MM: SS
*The date input format of endDate is YYYY-MM-DD HH: MM: SS
*Old version:THS_HighFrequenceSequence('thsCode1,thsCode2,thsCode3','indicator1;indicator2;indicator3','param1,param2,param3','startTime','endTime')
             */
            strOut = THS_HighFrequenceSequence("301279.SZ,600000.SH", "open;high;low;close;avgPrice;volume;amount;change;changeRatio;turnoverRatio;sellVolume;buyVolume", "Fill:Original", "2021-12-31 09:15:00", "2021-12-31 15:15:00");
            Console.WriteLine(strOut);
        }

        static void Snapshot()
        {
            string strOut;
            //Intraday snapshot
            strOut = THS_Snapshot("300033.SZ", "open;high;low", "", "2022-06-13 09:15:00", "2022-06-13 15:15:00");
            Console.WriteLine(strOut);
        }

        static void RealtimeQuotesSample()
        {
            string strOut;
            //Request real-time data
/*The format of the real-time market function is THS _ RealtimeQuotes (' thsCodes', 'indicators', 'params ')
*ThsCodes cannot be null and supports multiple inputs. When there are multiple thsCodes, they are separated by English half-width commas, such as thsCode 1, thsCode 2, thsCode 3
*Indicators cannot be null and support multiple inputs. When there are multiple indicators, they are separated by English semi-semicolons, such as indicator 1; indicator 2; indicator 3
*Params cannot be empty
*Old version: THS _ RealtimeQuotes (' thsCode 1, thsCode 2, thsCode 3 ',' indicator 1; indicator 2; indicator 3 ',' param1, param2, param3 ')
*The third parameter, 'pricetype: 1', is a parameter of the bond quotation method. The super command generates other securities types without this parameter, but please do not fill in the blanks, and fill in 'pricetype: 1' according to the following command
             */
            strOut = THS_RealtimeQuotes("300033.SZ,600000.SH", "open;high;low;latest;latestAmount;latestVolume", "pricetype:1");
            Console.WriteLine(strOut);
        }

        static void HistoryQuotesSample()
        {
            string strout;
            //Request historical quotations
/*
*Obtain the opening, high and low closing data of a RoyalFlush (300033. SZ) from 2016-08-23 to 2016-11-23 through the historical market function
*The historical market function format is THS _ HistoryQuotes (' thsCodes', 'indicators', 'params', 'startDate', 'endDate ')
*ThsCodes cannot be null and supports multiple inputs. When there are multiple thsCodes, they are separated by English half-width commas, such as thsCode 1, thsCode 2, thsCode 3
*Indicators cannot be null and support multiple inputs. When there are multiple indicators, they are separated by English semi-semicolons, such as indicator 1; indicator 2; indicator 3
*Params cannot be null and supports multiple inputs. When using default parameters, you can use 'default' to indicate that when the user only sets one of the indicators and the other parameters remain default, only the set parameters need to be entered, such as' period: W'
*The date input format for startDate is YYYY-MM-DD
*The date input format of endDate is YYYY-MM-DD
*Old version:THS_HistoryQuotes('thsCode1,thsCode2,thsCode3','indicator1;indicator2;indicator3','param1,param2,param3','startDate','endDate')
             */
            strout = THS_HistoryQuotes("300033.SZ,600000.SH", "open,high,low,close", "fill:Blank", "2021-11-09", "2021-12-08");
            Console.WriteLine(strout);
        }

        static void BasicDataSample()
        {
            string strOut;
            //Request basic data
/*Basic Data THS _ BasicData (' thsCodes', 'function', 'params '); supports multi-security single indicator input
*ThsCodes cannot be null and supports multiple inputs. When there are multiple thsCodes, they are separated by English half-width commas, such as thsCode 1, thsCode 2, thsCode 3
*The function cannot be empty, and only a single function is currently supported. The current function name can be viewed in [iFinD Terminal-Tools-Data Interface-Indicator Function Query Tool]
*Params can be empty or there can be multiple. When there are multiple params, they are separated by English half-width commas, such as param1, param2, param3
             * THS_BasicData('thsCode1,thsCode2,thsCode3','function','param1,param2,param3')
             */
            strOut = THS_BasicData("300033.SZ,600000.SH", "ths_total_shares_stock;ths_float_ashare_stock", "2022-01-08;2022-01-08");
            Console.WriteLine(strOut);
        }

        static void DateSequenceSample()
        {
            string strOut;
            //Request date sequence
/*The date series function format is THS _ DateSequence (' thsCodes', 'indicators', 'params', 'startDate', 'endDate ')
*ThsCodes cannot be null and supports multiple inputs. When there are multiple thsCodes, they are separated by English half-width commas, such as thsCode 1, thsCode 2, thsCode 3
*Indicators cannot be null and support multiple inputs. When there are multiple indicators, they are separated by English semi-semicolons, such as indicator 1; indicator 2; indicator 3
*Params cannot be null and supports multiple inputs. When using default parameters, it can be represented by 'default'. When the user only sets one of the indicators and the other parameters remain default, only the set parameters need to be entered, such as' Interval: M'
*The date input format for startDate is YYYY-MM-DD
*The date input format of endDate is YYYY-MM-DD
*Old version:THS_DateSequence('thsCode1,thsCode2,thsCode3','indicator1;indicator2;indicator3','param1,param2,param3','startDate','endDate')
             */
            strOut = THS_DateSerial("000001.SH", "ths_pe_index;ths_pb_index;ths_ps_index", "100,100;100,100;100,100", "Fill:Blank,block:history", "2021-03-23", "2021-04-23");
            Console.WriteLine(strOut);
        }

        static void DataPoolSample()
        {
            string strOut;
            //Request data pool
/*
*The data pool function format is THS _ DataPool (' modelName ',' inputParams', 'outputParams ')
*ModelName cannot be empty and can only be entered one at a time
*InputParams are separated by English semi-semicolons, such as inputParam 1; inputParam 2; inputParam 3
*OutputParams are assigned with English half-width colons, separated by English half-width commas, Y means the field output, N means the field is not output, if not written, the default is Y, such as outputParam 1: Y, outputParam 2: Y, outputParam 3: N
*THS_DataPool('modelName','inputParam1;inputParam2;inputParam3','outputParam1,outputParam2,outputParams3')
*【001005010】is the sector ID. At present, the sector ID can be viewed in【iFinD Terminal-Tools-Data Interface-Sector ID Query Tool】
*/
StrOut = THS _ DataPool (" block "," latest; 001005010 "," date: Y, thscode: Y, security _ name: Y, security _ name _ in _ time: Y ");
Console.WriteLine(strOut);

        }
		
		 static void DataReport()
        {
            string strOut;
            strOut = THS_DR("p00001", "sclx=SSE&SZSE", "p00001_f001:Y,p00001_f002:Y,p00001_f005:Y,p00001_f007:Y");
            Console.WriteLine(strOut);

        }

        static void EDBQuerySample()
        {
            string strout;
            //Request EDB Macroeconomic Data
/*The EDB data request function format is THS _ EDBQuery (' indicatorIDs', 'startDate', 'endDate ')
*IndicatorIDs cannot be empty and support multiple ID inputs. The indicator ID can be viewed in the indicator ID query tool in [iFinD Terminal-Tools-Data Interface]
*The date input format for startDate is YYYY-MM-DD
*The date input format of endDate is YYYY-MM-DD
             */
            strout = THS_EDBQuery("M001620247", "2020-01-01", "2020-12-31");
            Console.WriteLine(strout);
        }

        static void DataStatisticsSample()
        {
            string strout;
            //User data usage query function
/*
*The data usage query function is used for users to query the data usage of their own accounts. The market data is 150 million pieces/week, the basic data is 5 million pieces/week, and the EDB data is 500 pieces/week;
*The data obtained through high-frequency sequence functions, historical market functions and real-time market functions are collectively referred to as market data;
*The data obtained through the basic data function, date sequence function and data pool function are collectively referred to as basic data;
*The data obtained through the EDB data request function is collectively referred to as EDB data.
             */
            strout = THS_DataStatistics();
            Console.WriteLine(strout);
        }

        static void GetErrorInfoSample()
        {
            string strout;
            //Error code information query
/*Error information query function, query the errorcode after the function is executed, and understand the error information
*The value of value cannot be null, and the value of value must be an enumerated error value
             */
            strout = THS_GetErrorInfo(-1);
            Console.WriteLine(strout);
        }

        static void DateQuerySample()
        {
            string strout;
            //It is convenient for users to query the exchange's trading calendar within their customized time interval
/*
*Transaction Date/Calendar Date Query Function
*The format of the date query function is THS _ DateQuery (' exchange ',' dateType: value, period: value, dateFormat: value ',' startDate ',' endDate ')
*Exchange cannot be empty
*The values of dateType, period, and dateFormat cannot be empty either
*The date input format for startDate is YYYY-MM-DD
*The date input format of endDate is YYYY-MM-DD
             */
            strout = THS_Date_Query("212001", "mode:1,dateType:0,period:D,dateFormat:0", "2022-05-19", "2022-05-19");
            Console.WriteLine(strout);
        }

        static void DateOffsetSample()
        {
            string strout;
            //Query the corresponding transaction date according to the user-specified date and offset
/*
*Find the corresponding date based on the specified date and offset
*The format of the date offset function is THS _ DateQuery (' exchange ',' dateType: value, period: value, dateFormat: value ',' date ')
*Exchange cannot be empty
*The values of dateType, period, and dateFormat cannot be empty either
*The date input format for date is YYYY-MM-DD
             */
            strout = THS_Date_Offset("212001", "dateType:0,period:D,offset:0,dateFormat:0,output:singledate", "2022-05-19");
            Console.WriteLine(strout);
        }

        static void DateCountSample()
        {
            string strout;
            //It is convenient for users to uniformly query the total number of transaction dates within their customized time interval
/*
*Count the number of dates in the specified time interval and date type
*The format of the date query function is THS _ DateCount (' exchange ',' dateType: value, period: value, dateFormat: value ',' startDate ',' endDate ')
*Exchange cannot be empty
*The values of dateType, period, and dateFormat cannot be empty either
*The date input format for startDate is YYYY-MM-DD
*The date input format of endDate is YYYY-MM-DD
             */
            strout = THS_DateCount("SSE", "dateType:trade,period:D,dateFormat:0", "2016-07-21", "2017-08-21");
            Console.WriteLine(strout);
        }


/********************************************************************************************************************************************************************/

        [DllImport(strDllFile, CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode)]
        public static extern int FT_ifinDLogin(string strUserName, string strPassWord, int nType);

        [DllImport(strDllFile, CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode)]
        public static extern int FT_ifinDLogout();

        [DllImport(strDllFile, CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode)] 
        unsafe public static extern IntPtr FTQueryTHS_SynDateCountC(string ExchangeCode, //exchange
                                                     string Param, //parameter
                                                     string startDate, //Parameters required by the function
                                                     string endDate,
                                                     out  char* pret
                                                     );


        [DllImport(strDllFile, CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode)] 
        unsafe public static extern IntPtr FTQueryTHS_SynDateOffsetC(string ExchangeCode, //exchange
                                                     string Param, //parameter
                                                     string endDate,
                                                     out  char* pret
                                                     );


        [DllImport(strDllFile, CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode)]
        unsafe public static extern IntPtr FTQueryTHS_SynDate_OffsetC(string ExchangeCode, //exchange
                                                     string Param, //parameter
                                                     string endDate,
                                                     out  char* pret
                                                     );


        [DllImport(strDllFile, CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode)] 
        unsafe public static extern IntPtr FTQueryTHS_SynDateQueryC(string ExchangeCode, //exchange
                                                     string Param, //parameter
                                                     string startDate, //Parameters required by the function
                                                     string endDate,
                                                     out  char* pret
                                                     );



        [DllImport(strDllFile, CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode)]
        unsafe public static extern IntPtr FTQueryTHS_SynDate_QueryC(string ExchangeCode, //exchange
                                                     string Param, //parameter
                                                     string startDate, //Parameters required by the function
                                                     string endDate,
                                                     out  char* pret
                                                     );



        [DllImport(strDllFile, CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode)]
        unsafe public static extern int FTQueryTHS_SynDataPoolC(string DataPoolName, //data pool
                                                     string jsonIndicator, //
                                                     string jsonParam, //Parameters required by the function
                                                     out  char* pret
                                                     );



        [DllImport(strDllFile, CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode)]
		unsafe public static extern int FTQueryTHS_SynDRC(string DataReportID, //Thematic report ID
                                                    string jsonIndicator, //Report parameters
                                                    string jsonParam, //Report column name
                                                    out  char* pret
                                                    );



        [DllImport(strDllFile, CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode)]
        unsafe public static extern int FTQueryTHS_SynDateSeriesC(string THSCodes, //RoyalFlush code
                                                     string jsonIndicator, //Indicators and parameters required by the indicators
                                                     string jsonParam, //Parameters required by the function
                                                     string begintime,
                                                     string endtime,
                                                     out  char* pret
                                                     );

		[DllImport(strDllFile, CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode)] 
        unsafe public static extern int FTQueryTHS_SynDateSerialC(string THSCodes, //RoyalFlush code
                                                     string jsonIndicator, //Indicator
                                                     string jsonParam, //Parameters required by the function
													 string globalParam,
                                                     string begintime,
                                                     string endtime,
                                                     out  char* pret
                                                     );


        [DllImport(strDllFile, CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode)] 
        unsafe public static extern int FTQueryTHS_SynBasicDataC(string THSCodes, //RoyalFlush code
                                                     string jsonIndicator, //Indicator
                                                     string jsonParam, //Parameters required by the function
                                                     out  char* pret
                                                     );



        [DllImport(strDllFile, CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode)] 
        unsafe public static extern int FTQueryTHS_SynHisQuoteC(string THSCodes, //RoyalFlush code
                                                     string jsonIndicator, //Indicators and parameters required by the indicators
                                                     string jsonParam, //Parameters required by the function
                                                     string begintime,
                                                     string endtime,
                                                     out  char* pret
                                                     );

        [DllImport(strDllFile, CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode)] 
        unsafe public static extern int FTQueryTHS_SynRTByJsonC(string THSCodes, //RoyalFlush code
                                                     string jsonIndicator, //Indicators and parameters required by the indicators
                                                     string jsonParam, //Parameters required by the function
                                                     out  char* pret
                                                     );

        [DllImport(strDllFile, CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode)]
        unsafe public static extern int FTQueryTHS_SynHFQByJsonC(string THSCodes,
                                                      string jsonIndicator,
                                                      string jsonParam,
                                                      string begintime,
                                                      string endtime,
                                                      out  char* pret);

        [DllImport(strDllFile, CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode)]
        unsafe public static extern int FTQueryTHS_SynEDBQueryC(string jsonIndicator,                                                    
                                                      string begintime,
                                                      string endtime,
                                                      out  char* pret);

        [DllImport(strDllFile, CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode)]
        unsafe public static extern int FTQueryTHS_SynSnapshotQueryC(string THSCodes,
                                                      string jsonIndicator,
                                                      string jsonParam,
                                                      string begintime,
                                                      string endtime,
                                                      out  char* pret);

        [DllImport(strDllFile, CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode)]
        unsafe public static extern int FTQueryTHS_SynGetErrorInfoC(int errorcode,
                                                      out  char* pret);

        [DllImport(strDllFile, CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode)]
        unsafe public static extern IntPtr FTQuery_SynDataStasticsC(out int errorcode, void* reserve1, void* reserve2, void* reserve3);



        [DllImport(strDllFile, CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode)]
        unsafe public static extern void DeleteBuffer(char* pret);

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//The encapsulated function command can be called directly according to the following encapsulation interface

        static int THS_iFinDLogin(string UserAcount, string Password)
        {
            int nRet = FT_ifinDLogin(UserAcount, Password, 0);
            return nRet;
        }

        static int THS_iFinDLogout()
        {
            int nRet = FT_ifinDLogout();
            return nRet;
        }

        unsafe static string THS_HighFrequenceSequence(string THSCodes,
                                                      string jsonIndicator,
                                                      string jsonParam,
                                                      string begintime,
                                                      string endtime)//High frequency sequence new version interface
        {
            string strOut;
            char* Pret;
            FTQueryTHS_SynHFQByJsonC(THSCodes, jsonIndicator, jsonParam, begintime, endtime, out  Pret);
            IntPtr data = new IntPtr(Pret);
            strOut = Marshal.PtrToStringUni(data);
            DeleteBuffer(Pret);
            return strOut;
        }

        unsafe static string THS_Snapshot(string THSCodes,
                                                      string jsonIndicator,
                                                      string jsonParam,
                                                      string begintime,
                                                      string endtime)//Intraday snapshot
        {
            string strOut;
            char* Pret;
            FTQueryTHS_SynSnapshotQueryC(THSCodes, jsonIndicator, jsonParam, begintime, endtime, out  Pret);
            IntPtr data = new IntPtr(Pret);
            strOut = Marshal.PtrToStringUni(data);
            DeleteBuffer(Pret);
            return strOut;
        }

        unsafe static string THS_RealtimeQuotes(string THSCodes, //RoyalFlush code
                                                     string jsonIndicator, //Indicators and parameters required by the indicators
                                                     string jsonParam //Parameters required by the function
                                                       )//Real-time market new version interface
        {
            string strOut;
            char* Pret;
            FTQueryTHS_SynRTByJsonC(THSCodes, jsonIndicator, jsonParam, out  Pret);
            IntPtr data = new IntPtr(Pret);
            strOut = Marshal.PtrToStringUni(data);
            DeleteBuffer(Pret);
            return strOut;
        }

        unsafe static string THS_HistoryQuotes(string THSCodes, //RoyalFlush code
                                                     string jsonIndicator, //Indicators and parameters required by the indicators
                                                     string jsonParam, //Parameters required by the function
                                                     string begintime,
                                                     string endtime
                                                     )//The new version of the historical market interface
        {
            string strOut;
            char* Pret;
            FTQueryTHS_SynHisQuoteC(THSCodes, jsonIndicator, jsonParam, begintime, endtime, out  Pret);
            IntPtr data = new IntPtr(Pret);
            strOut = Marshal.PtrToStringUni(data);
            DeleteBuffer(Pret);
            return strOut;
        }

        unsafe static string THS_BasicData(string THSCodes, //RoyalFlush code
                                                     string jsonIndicator, //Indicator
                                                     string jsonParam //Parameters required by the function
                                                     )//Basic data new version interface
        {
            string strOut;
            char* Pret;
            FTQueryTHS_SynBasicDataC(THSCodes, jsonIndicator, jsonParam, out  Pret);
            IntPtr data = new IntPtr(Pret);
            strOut = Marshal.PtrToStringUni(data);
            DeleteBuffer(Pret);
            return strOut;
        }

        // unsafe static string THS_DS(string THSCodes, //RoyalFlush code
                                                     // string jsonIndicator, //Indicators and parameters required by the indicators
                                                     // string jsonParam, //Parameters required by the function
                                                     // string begintime,
                                                     // string endtime)//Date series new version interface
        // {
            // string strOut;
            // char* Pret;
            // FTQueryTHS_SynDateSeriesC(THSCodes, jsonIndicator, jsonParam, begintime, endtime, out  Pret);
            // IntPtr data = new IntPtr(Pret);
            // strOut = Marshal.PtrToStringUni(data);
            // DeleteBuffer(Pret);
            // return strOut;
        // }

        unsafe static string THS_DateSerial(string THSCodes, //RoyalFlush code
                                                     string jsonIndicator, //Indicator
                                                     string jsonParam, //Parameters required by the function
													 string globalParam,
                                                     string begintime,
                                                     string endtime)//Date series new version interface
        {
            string strOut;
            char* Pret;
            FTQueryTHS_SynDateSerialC(THSCodes, jsonIndicator, jsonParam, globalParam, begintime, endtime, out  Pret);
            IntPtr data = new IntPtr(Pret);
            strOut = Marshal.PtrToStringUni(data);
            DeleteBuffer(Pret);
            return strOut;
        }

        unsafe static string THS_DataPool(string DataPoolName, //Data pool
                                                     string jsonIndicator, //
                                                     string jsonParam //Parameters required by the function
                                                     )//The new version of the data pool interface
        {
            string strOut;
            char* Pret;
            FTQueryTHS_SynDataPoolC(DataPoolName, jsonIndicator, jsonParam, out  Pret);
            IntPtr data = new IntPtr(Pret);
            strOut = Marshal.PtrToStringUni(data);
            DeleteBuffer(Pret);
            return strOut;
        }
		
		unsafe static string THS_DR(string DataReportID, //Thematic report ID
                                             string jsonIndicator, //Report parameters
                                             string jsonParam //Report column
                                             )//Thematic report interface
        {
            string strOut;
            char* Pret;
            FTQueryTHS_SynDRC(DataReportID, jsonIndicator, jsonParam, out  Pret);
            IntPtr data = new IntPtr(Pret);
            strOut = Marshal.PtrToStringUni(data);
            DeleteBuffer(Pret);
            return strOut;
        }

        unsafe static string THS_Date_Query(string ExchangeCode, //Exchange
                                                     string Param, //parameter
                                                     string startDate, //Parameters required by the function
                                                     string endDate)//Date query new version interface
        {
            string strOut;
            char* Pret;
            FTQueryTHS_SynDate_QueryC(ExchangeCode, Param, startDate, endDate, out  Pret);
            IntPtr data = new IntPtr(Pret);
            strOut = Marshal.PtrToStringUni(data);
            DeleteBuffer(Pret);
            return strOut;
        }

        unsafe static string THS_Date_Offset(string ExchangeCode, //Exchange
                                                     string Param, //parameter
                                                     string endDate)//Date query new version interface
        {
            string strOut;
            char* Pret;
            FTQueryTHS_SynDate_OffsetC(ExchangeCode, Param, endDate, out  Pret);
            IntPtr data = new IntPtr(Pret);
            strOut = Marshal.PtrToStringUni(data);
            DeleteBuffer(Pret);
            return strOut;
        }

        unsafe static string THS_DateCount(string ExchangeCode, //Exchange
                                                     string Param, //parameter
                                                     string startDate, //Parameters required by the function
                                                     string endDate)//Date query new version interface
        {
            string strOut;
            char* Pret;
            FTQueryTHS_SynDateCountC(ExchangeCode, Param, startDate, endDate,  out  Pret);
            IntPtr data = new IntPtr(Pret);
            strOut = Marshal.PtrToStringUni(data);
            DeleteBuffer(Pret);
            return strOut;
        }

        unsafe static string THS_EDBQuery(string jsonIndicator,
                                                      string begintime,
                                                      string endtime
                                                      )
        {
            string strOut;
            char* Pret;
            FTQueryTHS_SynEDBQueryC(jsonIndicator, begintime, endtime, out  Pret);
            IntPtr data = new IntPtr(Pret);
            strOut = Marshal.PtrToStringUni(data);
            DeleteBuffer(Pret);
            return strOut;
        }

        unsafe static string THS_DataStatistics()
        {
            string strOut;
            int code;
            strOut = Marshal.PtrToStringUni(FTQuery_SynDataStasticsC(out code, null, null, null));
            return strOut;
        }

        unsafe static string THS_GetErrorInfo(int code)
        {
            string strOut;
            char* Pret;
            FTQueryTHS_SynGetErrorInfoC(code, out  Pret);
            IntPtr data = new IntPtr(Pret);
            strOut = Marshal.PtrToStringUni(data);
            DeleteBuffer(Pret);
            return strOut;
        }
/**********************************************************************************************************************************************/

    }
}