package com.ess.test;

import com.sun.org.apache.xml.internal.utils.URI;
import com.ess.helper.QueueHelper;
import org.apache.http.HttpHost;
import org.apache.http.HttpResponse;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.config.ConnectionConfig;
import org.apache.http.impl.nio.client.CloseableHttpAsyncClient;
import org.apache.http.impl.nio.client.HttpAsyncClients;
import org.apache.http.impl.nio.conn.PoolingNHttpClientConnectionManager;
import org.apache.http.impl.nio.reactor.DefaultConnectingIOReactor;
import org.apache.http.nio.reactor.ConnectingIOReactor;
import org.apache.http.nio.reactor.IOReactorException;
import org.apache.http.util.EntityUtils;
import com.ess.system.SrConfig;
import com.ess.system.network.newhttp.SmsSenderInfoReminderNew;

import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.regex.Pattern;

import static com.ess.data.Constant.tps_count_send_sms_inforeminder;

//import com.ess.mbpultimate.manager.ServiceManagement;

import com.ess.data.Constant;

import static com.ess.data.Constant.*;
import static com.ess.data.Constant.tps_count_httpserver_smsreply;
//import static com.ess.data.HttpConstant.*;

public class MainTestHttpIR {

    private int second_count = 0;
    private int minute = 0;
    private int hour = 0;
    private AtomicInteger trx = new AtomicInteger(0);
    private int count_seconds = 0;

    public static boolean useTpsLimit = true;
    public static boolean useTransactionLimit = false;

    public static AtomicInteger transactionLimit = new AtomicInteger(0);
    public static AtomicInteger tpsLimit = new AtomicInteger(80);

    public static AtomicInteger tpscounter = new AtomicInteger(0);

    private static MainTestHttpIR instance = null;
    LinkedBlockingQueue<Runnable> executor_queue = new LinkedBlockingQueue<>();
    ThreadPoolExecutor executor;

    public static MainTestHttpIR getInstance() {
        if(instance == null)
            instance = new MainTestHttpIR();
        return instance;
    }

    public MainTestHttpIR() {
        executor = new ThreadPoolExecutor(100, 100, 0L, TimeUnit.MILLISECONDS, executor_queue);
        Timer timer_display = new Timer(true);
        timer_display.scheduleAtFixedRate(new DisplayTimer(), 0, 1000);
    }

    public void execute(String content){
        HttpThreadRunner runner = new HttpThreadRunner(content);
        executor.execute(runner);
    }

    public class HttpThreadRunner implements Runnable{
        String content;

        public HttpThreadRunner(String content) {
            this.content = content;
        }

        @Override
        public void run() {
            HttpSendSmsBulks.getInstance().send(content);
        }
    }


    public static void main(String[] args) {
        if (args.length < 2 && args[1].equals("true")){
            System.out.println("-Use java -jar Hit.jar false 5000 for execute without TPS limit and 5000 transaction");
            System.out.println("-Use java -jar Hit.jar true 100 5000 for execute with TPS limit 100 and 5000 transaction");
        }else {
            useTpsLimit = Boolean.valueOf(args[0]);
            if(useTpsLimit) tpsLimit.set(Integer.valueOf(args[1]));
            transactionLimit.set(Integer.valueOf(args[2]));
            SrConfig.getInstance();
            QueueHelper.getInstance();
            try {
                SmsSenderInfoReminderNew.getInstance();
                MainTestHttpIR.getInstance();
                for (int i = 0; i < transactionLimit.get(); i++) {
                    String line_content = Long.parseLong("62810000000")+i + "<>41541<>1<>192.168.1.8/hit-mbp-cr1/ingwc.php<>TesTimertask<>TesTimertask<>" + i;
                    MainTestHttpIR.getInstance().execute(line_content);
//                    QueueHelper.getInstance().addSmsInfoReminder(FakeEntityUtils.encodeSmsInfoReminder("tes", ""+(Long.parseLong("62810000000")+i), "false"));
                }

            } catch (Exception e) {
                e.printStackTrace();
                System.out.println(String.valueOf(e.getMessage()));
            }
        }
    }

    class DisplayTimer extends TimerTask {

        @Override
        public void run() {

            count_seconds++;
//            System.out.println("TPS SMS:" + tps_count_send_sms_inforeminder.get());
            System.out.println("TPS: " + MainTestHttpIR.tpscounter.get());

            MainTestHttpIR.tpscounter.set(0);
//            tps_count_send_sms_inforeminder.set(0);

            if (second_count > 59) {
                if (minute > 59) {
                    hour++;
                    minute = 0;
                } else {
                    minute++;
                }
                second_count = 0;
            } else {
                second_count++;
            }

        }
    }
}


class HttpSendSmsBulks{
    AtomicInteger trx_id = new AtomicInteger(0);
    private CloseableHttpAsyncClient httpclient = null;
    private RequestConfig globalRequestConfig;
    private static HttpSendSmsBulks instance = null;
    private static AtomicInteger counter;
    private HttpSendSmsBulks() {
        ConnectingIOReactor ioreactor = null;
        counter = new AtomicInteger(0);
        try {
            ioreactor = new DefaultConnectingIOReactor();
            PoolingNHttpClientConnectionManager mgr = new PoolingNHttpClientConnectionManager(ioreactor);
            mgr.setDefaultConnectionConfig(ConnectionConfig.DEFAULT);
            mgr.setDefaultMaxPerRoute(1000);
            mgr.setMaxTotal(6000);
            httpclient = HttpAsyncClients.createPipelining(mgr);
        } catch (IOReactorException e) {
//            LogUtils.getInstance().writeLog(ServiceManagement.class, LogUtils.Level.ERROR, e.toString());
        }
        httpclient.start();
        RequestConfig.Builder requestBuilder = RequestConfig.custom();
        requestBuilder = requestBuilder.setConnectTimeout(10000);
        requestBuilder = requestBuilder.setSocketTimeout(10000);
        requestBuilder = requestBuilder.setConnectionRequestTimeout(10000);
        globalRequestConfig = requestBuilder.build();
    }

    public static HttpSendSmsBulks getInstance(){
        if(instance == null){
            instance = new HttpSendSmsBulks();
        }
        return instance;
    }

    public void send(String content){
        if (MainTestHttpIR.useTpsLimit) {
            while ((MainTestHttpIR.tpscounter.get() >= MainTestHttpIR.tpsLimit.get())) {
                //holding process TPS LIMIT
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                }
            }
        }
        MainTestHttpIR.tpscounter.incrementAndGet();
        //http://localhost:2222/smsMo?msisdn=6281748820132&adn=41541&partner_name=1&partner_url=192.168.1.8/hit-mbp-cr1/ingwc.php&username=tes&password=tes&trx_id=123&channel=http
        String msisdn = "NO MSISDN";
        String trxid = "notrx";
        try {
            String[] line_data = content.split(Pattern.quote("<>"));
            msisdn = line_data[0];
            trxid = line_data[6];
//            String host = "http://localhost:2222";
            String host = "http://essmalang.ddns.net";
//            String host = "http://192.168.1.8";
            URI uriHost = new URI(host);
            String query = "/hit-mbp-cr1/smsgw.php?"
                    + "trx_id=" + trxid
                    + "&msg=" + "tes"
                    + "&from=telkomsel"
                    + "&to=" + line_data[0];
//            String query = "/";
            HttpHost targetHost = new HttpHost(uriHost.getHost(), uriHost.getPort());
//            System.out.println(host+query);
            HttpGet httpGet = new HttpGet(query);
//            );
            httpGet.setHeader("User-Agent", "Hit");
            httpGet.setConfig(globalRequestConfig);
            Future<HttpResponse> future = httpclient.execute(targetHost, httpGet, null);
            HttpResponse responses = future.get(10000, TimeUnit.MILLISECONDS);
            String response = EntityUtils.toString(responses.getEntity());
//            System.out.println("request: "+content+" | response: "+response);
//            System.out.println("counter: "+counter.addAndGet(1)+" msisdn: "+msisdn+" trx_id:"+trxid+" "+ DateUtils.getNowDateTime()+" "+response);
//            WriteLog(msisdn, response);
//            MyLogger.WriteLog(msisdn, response);
        }catch (TimeoutException e){
//            WriteLog(msisdn, "Timeout Exception");
//            MyLogger.WriteLog(msisdn, "Timeout Exception");
//            System.out.println("counter: "+counter.addAndGet(1)+" msisdn: "+msisdn+" trx_id:"+trxid+" "+DateUtils.getNowDateTime()+" TimeoutException");
        }catch (Exception e){
//            WriteLog(msisdn, "Exception: "+e.getMessage());
//            MyLogger.WriteLog(msisdn, "Exception: "+e.getMessage());
//            System.out.println("counter: "+counter.addAndGet(1)+" msisdn: "+msisdn+" trx_id:"+trxid+" "+DateUtils.getNowDateTime()+" "+e.getMessage());
        }
    }

}