package sourcecode.MockUp;

import java.io.IOException;
import java.io.OutputStream;

import java.net.InetSocketAddress;

import java.net.URLDecoder;

import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.sql.Date;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.Iterator;

import org.apache.commons.io.IOUtils;
import org.apache.http.Consts;
import org.bson.Document;

import org.json.JSONArray;

import org.json.JSONObject;

import com.google.gson.Gson;

import com.google.gson.JsonObject;

import com.mongodb.BasicDBObject;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.MongoClientURI;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpServer;

public class MockUp 
{

	private static Gson gson = new Gson();

	private static MongoDatabase database;
	private final static String GET = "GET";
	private final static String POST = "POST";
	private final static String PUT = "PUT";
	private final static String DELETE = "DELETE";

	private static int port = 6300;

	private static String DBNAME = "sdf";
	private static String DBHOST = "10.1.2.146:27017";

	private static String DBUSERNAME = "";
	private static String DBPASSWORD = "";
	

	
	public static void main(String[] args) throws Exception {
		

		try {

			if(args.length>0)
				port = Integer.parseInt(args[0]);
			

			if(args.length>1)
				DBNAME = args[1];
			
			if(args.length>2)
				DBHOST = args[2];
			

			if(args.length>3)
				DBUSERNAME = args[3];
			
			if(args.length>4)
				DBPASSWORD = args[4];
			

	        //connect mongo

			MongoConnector(DBNAME);	       

	        
			HttpServer server = HttpServer.create(new InetSocketAddress(port), 0);	       
	        server.createContext("/", new MyHandler());
	        server.setExecutor(null); // creates a default executor
	        server.start();
			System.out.println("Run in port : "+port);

		} catch(Exception e) {

			e.printStackTrace();
			System.out.println("Fail to run in port : "+port);
		}
    }

    static class MyHandler implements HttpHandler {

    	JSONObject resHeader = null;
    	int resEcode = 200;
    	

        public void handle(HttpExchange t) throws IOException{

        	String response = "";

        	try
        	{        	
	        	String method = t.getRequestMethod();        	
	        	String url = t.getRequestURI().toString();
	        	url = URLDecoder.decode(url, "UTF-8");

	        	String bodyData = IOUtils.toString(t.getRequestBody(),Consts.UTF_8); 
	        	
	        	
	        	int limit = 0;
	        	
	        	if(!getKey("limit", url).equals(""))
	        	{
	        		try{
	        			limit = Integer.parseInt(getKey("limit", url));
	        		}catch(Exception e) 
	        		{
	        			
	        		}
	        	}

	        	
	        	int offset = 0;
	        	
	        	if(!getKey("offset", url).equals(""))
	        	{
	        		try{
	        			offset = Integer.parseInt(getKey("offset", url));
	        		}catch(Exception e) 
	        		{
	        			
	        		}
	        	}

	        		
	        	
	        	String[] fields = new String[0];
	        	if(!getKey("fields", url).equals(""))
	        		fields = getKey("fields", url).split(",");
	        	     	

	        	
	//        	System.out.println(t.getRequestMethod());
	//        	if(!method.equals(GET))
	//        	{
	//	        	String bodyData = IOUtils.toString(t.getRequestBody(),Consts.UTF_8); 
	//	        	JSONObject body = new JSONObject(bodyData);
	//	        	String[] a = bodyData.split(",");
	//	//        	System.out.println(a[0]);
	//	        	String[] b = a[0].split(":");
	//	//        	System.out.println(b[0]);
	//	        	String c = b[0].replace("{", "").trim().replace("\"", "");
	//	//        	System.out.println(c);
	//	        	keyBody = (String) body.get(c);
	//        	}
	//        	System.out.println(body.get(c));
	        	
	//        	for(Entry<String, List<String>> row:t.getRequestHeaders().entrySet())
	//        	{
	//        		System.out.println(row.getKey());
	//        		System.out.println(row.getValue());
	//        	}
	//        	System.out.println(t.getRequestHeaders());
	//        	System.out.println(t.getRequestURI());
	          
	        	

	        	String keyData = findKey(method,url,bodyData);

	        	
	        	String collectionName = getSuffixTableName(url);     	
	        	JSONObject responsJSON = new JSONObject();
	        	
	        	//find retry
	        	
	        	ArrayList<String> retryList = findRetry(method,keyData);
	        	boolean notRetry = true;
	
	        	if(retryList.size() > 0)
	        	{
	        		JSONObject rowJSON = new JSONObject(retryList.get(0));
	        		System.out.println("Count retry : "+rowJSON.get("count"));
	        		
	        		if(rowJSON.has("value"))
	        			responsJSON = (JSONObject) rowJSON.get("value");
	        		else
	        		{
	        			System.out.println("not found vale or resultCode");
	        			responsJSON.put("resultCode", "50000");
			    		responsJSON.put("resultDescription", "Retry");
	        		}
	        		
	            	BasicDBObject find = new BasicDBObject();
	            	find.put("key", rowJSON.get("key"));
	//            	System.out.println(rowJSON.get("count"));
	            	int newCount = (int) rowJSON.get("count");
	            	rowJSON.remove("count");
	            	if(newCount > 0)
	            	{
	            		rowJSON.put("count", newCount-1);
	            		Document doc = Document.parse(rowJSON.toString());            	
	            		setDB(find,doc,method.toLowerCase()+"_retry");
	            		notRetry = false;
	            	}
	            }
	        		
	        	
	        	if(notRetry)
	        	{

		        	ArrayList<String> responseList = getDBData(keyData,collectionName,method,bodyData);      	

		        	
		        	
		        	if(responseList.size() == 0)
		        	{
		        		System.out.println("not any Data");
		        		responsJSON.put("resultCode", "80000");
			    		responsJSON.put("resultDescription", "MockUp error : No data in "+method.toLowerCase()+"_"+collectionName+"!!!");
		        	}else
		        	{
		        		if(method.equals(GET) && responseList.size() > 1)
			    		{

		        			System.out.println("Multi Data => Merge");

		        			ArrayList<Object> resultData = new ArrayList<Object>();		    		
				        	for(int i=0;i<responseList.size();i++)
				        	{
				        		JSONObject rowJSON = new JSONObject(responseList.get(i));
				        		
				        		if(rowJSON.has("value"))
				        		{
				        			JSONObject value = (JSONObject) rowJSON.get("value");
				        			if(value.has("resultData"))
					        		{	

				        				try{
				        					JSONArray JSONArrayData = value.getJSONArray("resultData");

				        					for(int n=0;n<JSONArrayData.length();n++)

				        						resultData.add(JSONArrayData.get(n));

				        				}catch(Exception e)
				        				{				
//				        					e.printStackTrace();
				        					resultData.add(value.get("resultData"));
				        				}
				        				
					        		}
				        		}
				        		
		            		}
				        	
				        	responsJSON.put("resultCode", "20000");
				    		responsJSON.put("resultDescription", "Success");
				    		responsJSON.put("resultData",resultData);
				    		responsJSON.put("rowCount",resultData.size());
		        			
			    		}else
			    		{

			    			System.out.println("Single Data => Direct");

			    			JSONObject rowJSON = new JSONObject(responseList.get(0));			    			
			    			if(rowJSON.has("value"))
			    				responsJSON = (JSONObject) rowJSON.get("value");
			    			else
			    			{
			    				System.out.println("not found vale or resultCode");
			    				responsJSON.put("resultCode", "20000");
					    		responsJSON.put("resultDescription", "Success");
			    			}

			    			
			    			if(rowJSON.has("header"))
			    				resHeader = rowJSON.getJSONObject("header");
			    			else
			    				resHeader = null;
			    			
			    			if(rowJSON.has("ecode"))
			    				resEcode = rowJSON.getInt("ecode");
			    			else
			    				resEcode = 200;

			    		}
		        	}
		        	
		        	///////////////////////////////////////////////////////////////////////////////////////////////////////////////		        	
		        	

	        	}
	        	

	        	//limit

	        	if(method.equals(GET) && responsJSON.has("resultCode") && responsJSON.get("resultCode").equals("20000")) {
	        		responsJSON = offsetData(responsJSON,offset);
	        		responsJSON = limitData(responsJSON,limit);
	        	}

	        	
	        	//field
	        	responsJSON = FieldsData(responsJSON,fields); 
	        	
	    			

	        	
	        	response = responsJSON.toString();
	        	
	        	System.out.println("");
	            System.out.println("URL : " + url);
	            System.out.println("Method : " + method);
	            System.out.println("Response : " + response);
	            System.out.println("");
	        	
	        	}catch(Exception e) {
	    			e.printStackTrace();
	    			System.out.println("System error "+e.getMessage());
	    			
	    		}

        	if(resHeader != null)
        	{
        		Iterator<String> keys = resHeader.keys();
        		while(keys.hasNext()) {
        		    String key = keys.next();
        		    t.getResponseHeaders().set(key, resHeader.getString(key));        		    
        		}
        		
        	}

    	    String ret = response.toString();
    	    t.getResponseHeaders().set("Content-Type", "application/json");
    	    
    	    t.getResponseHeaders().set("Access-Control-Allow-Origin", "https://localhost:"+port);
    	    t.getResponseHeaders().set("Access-Control-Allow-Credentials", "true");
    	    t.getResponseHeaders().set("Access-Control-Allow-Headers", "content-Type");
    	    t.getResponseHeaders().set("Access-Control-Allow-Methods", "POST, PUT, GET, DELETE, OPTIONS");
    	    
    	    
    	    

    	    //ret= URLDecoder.decode(ret, "UTF-8");
    	    byte[] bytes = ret.getBytes(StandardCharsets.UTF_8);
    	    t.sendResponseHeaders(resEcode, bytes.length);
//    	    System.out.println(ret);
    	    OutputStream os = t.getResponseBody();
    	    os.write(bytes);
    	    os.close();
        	
        	
        	
        	
//        	t.getResponseHeaders().set("Content-Type", "application/json");
//        	t.sendResponseHeaders(200, response.length());
//        	OutputStream os = t.getResponseBody();  
//        	os.write(response.getBytes(Charset.forName("US-ASCII")));
////        	os.write(response.getBytes());        	
//            os.close();

        }
    }

    
    private static String getSuffixTableName(String url)
	{
		String value = null;
		String[] arrData = url.split("/");
		for (String data : arrData) {
		    if (data.contains(".json")) {
		    	int lastIndex = data.indexOf(".json");
		    	value = data.substring(0, lastIndex);
		    	break;
		    }
		}

		if(value == null)
			value = arrData[arrData.length-1];
		if(value.contains("?"))
		{
			arrData = value.split("\\?");
			value = arrData[0];
		}
		

		return value;
	}

   
    private static void MongoConnector(String db) {
    	

    	String username = DBUSERNAME;
		String password = DBPASSWORD.replace("@", "%40");

		String address = DBHOST;

		String dbname = db;

		String authSource = "admin";

		int timeoutMongoDB = 10000;		
		
		 MongoClientOptions.Builder optionsBuilder = MongoClientOptions.builder(); 
			optionsBuilder.connectTimeout(timeoutMongoDB); 
			optionsBuilder.socketTimeout(timeoutMongoDB); 
			optionsBuilder.serverSelectionTimeout(timeoutMongoDB);

//			optionsBuilder.connectionsPerHost(maxPoolSize);
//			optionsBuilder.minConnectionsPerHost(minPoolSize);

//			mongodb://root:password123@198.174.21.23:27017,198.342.121.23:27017,142.32.32.21:3001/databasename?replicaSet=rs01&ssl=false&connectTimeoutMS=100000

	        MongoClientURI uri = new MongoClientURI("mongodb://"+username+":"+password+"@"+address+"/?authSource="+authSource, optionsBuilder);
			if(username.equals(""))
				uri = new MongoClientURI("mongodb://"+address+"/?authSource="+authSource, optionsBuilder);
			System.out.println("MongoDB Connecting to "+uri.toString()+"...");

			@SuppressWarnings("resource")

			MongoClient mongoClient = new MongoClient(uri);
			database = mongoClient.getDatabase(dbname);
			//test connect and list collections
			MongoCursor<String> collectionNames = database.listCollectionNames().iterator();
			System.out.println("MongoDB Connect to "+uri.toString()+" Success");
			System.out.println("MongoDB Collections in datebase");
			while (collectionNames.hasNext()) {
				String collectionName = collectionNames.next();
				System.out.println(" |_ "+collectionName);		
				
			}
    }
    

    private static ArrayList<String> getDBData(String keyData,String collectionName,String method,String bodyData)

    {

    	ArrayList<String> returnData = new ArrayList<String>();

//    	collectionName = method.toLowerCase()+"_"+collectionName;

    	System.out.println("===> Find Normal");
    	BasicDBObject basicDBObject = new BasicDBObject();

//    	System.out.println(keyData);

    	basicDBObject.put("key", keyData);

    	returnData = getDB(basicDBObject,method.toLowerCase()+"_"+collectionName);

    	if(returnData.size() == 0)
    	{
    		System.out.println("===> Go to Main flow");
    		BasicDBObject basicDBObject2 = new BasicDBObject();
        	basicDBObject2.put("key", "");

    		returnData = getDB(basicDBObject2,method.toLowerCase()+"_"+collectionName);
    		
//    		if(method.equals(POST) && returnData.size()>0)
//    		{
//    			//post main flow
//    			JSONObject rowJSON = new JSONObject(returnData.get(0));
//    			rowJSON.remove("_id");
//    			JSONObject value = rowJSON.getJSONObject("value");
//    			value.put("resultData",  new JSONObject(bodyData));
//    			
//    			Document doc = Document.parse(rowJSON.toString());
//    			insertDB(doc,GET.toLowerCase()+"_"+collectionName);
//    		}

    	}    	
    	
    	

    	return returnData;
    }

    private static String findKey(String method,String url,String bodyData)
    {
    	String returnData = "";
    	

    	switch (method) {
		case GET:

		case DELETE:
			returnData = url;

			break;
		case POST:
		case PUT:

			try
			{
	        	JSONObject body = new JSONObject(bodyData);
	        	String[] a = bodyData.split(",");
	        	String[] b = a[0].split(":");
	        	String c = b[0].replace("{", "").trim().replace("\"", "");
	        	
	        	returnData = findKeyObject(body.get(c));
	//        	returnData = (String) body.get(c);
			}catch(Exception e)
			{
				returnData = "";
			}
        	
        	

			break;	
		

		default:
			break;
		}
    	

    	return returnData;
    }

    private static String findKeyObject(Object obj)
    {
    	String returnData = "";
    	if(obj instanceof JSONObject)
    	{
    		returnData = obj.toString();
//    		JSONObject json = (JSONObject) obj;
//    		String bodyData = obj.toString();
//    		String[] a = bodyData.split(",");
//        	String[] b = a[0].split(":");
//        	String c = b[0].replace("{", "").trim().replace("\"", "");
//    		returnData = findKeyObject(json.get(c));
    	}else
    		returnData = (String) obj;
    	
    	return returnData;
    }
    

    private static ArrayList<String> findRetry(String method,String keyData)
    {
    	ArrayList<String> returnData = new ArrayList<String>();
    	
    	System.out.println("===>Find retry");
    	BasicDBObject basicDBObject = new BasicDBObject();
    	basicDBObject.put("key", keyData);
    	String collectionName = method.toLowerCase()+"_retry";
    	returnData = getDB(basicDBObject,collectionName);
    	
    	if(returnData.size() == 0)
    	{
    		BasicDBObject basicDBObject2 = new BasicDBObject();
        	basicDBObject2.put("key", "");
    		returnData = getDB(basicDBObject2,collectionName);
    	}    	
    	
    	
    	return returnData;    	
    }
    
    private static ArrayList<String> getDB(BasicDBObject basicDBObject,String collectionName)
    {
    	ArrayList<String> returnData = new ArrayList<String>();
    	
    	System.out.println("CollectionName : " + collectionName);
    	System.out.println("Find : "+basicDBObject.toJson());
    	
    	MongoCollection<Document> collection = database.getCollection(collectionName);
    	FindIterable<Document> findData = collection.find(basicDBObject);
    	MongoCursor<Document> cursor = findData.iterator();
    	
    	while(cursor.hasNext()){
			Document rawRow = cursor.next(); 
			System.out.println("found retry _id : "+rawRow.get("_id"));
//			System.out.println("count : "+rawRow.get("count"));
			returnData.add(rawRow.toJson());
		}
    	 
		return returnData;
    	
    }
    
    private static void setDB(BasicDBObject find,Document doc,String collectionName)
    {
//    	System.out.println("Start Update Mongo");

    	MongoCollection<Document> collection = database.getCollection(collectionName);
    	Document updateDoc = collection.findOneAndReplace(find, doc);		
		
    	System.out.println("Update Mongo");
    }
    

    private static void insertDB(Document doc,String collectionName)
    {
//    	System.out.println("Start Update Mongo");

    	MongoCollection<Document> collection = database.getCollection(collectionName);
    	collection.insertOne(doc);	
		
    	System.out.println("Insert Mongo");
    }
   
    private static JSONObject limitData(JSONObject responsJSON,int limit)
    {
    	if(limit != 0)
		{
    		int size = 0;
        	try{
        		System.out.println("Limit : "+limit);
        		JSONArray JSONArrayData = responsJSON.getJSONArray("resultData");	        		
        		
	    		ArrayList<Object> limitResultData = new ArrayList<Object>();	
	    		size = JSONArrayData.length();
	    		for(int i=0;i<size;i++)
		        {				    				
	    			limitResultData.add(JSONArrayData.get(i));
	    			if(i == limit-1)
	    				i=JSONArrayData.length();
	    		}
	    		responsJSON.remove("resultData");
	    		responsJSON.put("resultData",limitResultData);		    		
        		
        	}catch(Exception e)
        	{
        		//resultData not array 
        		size = 1;
        	}

//        	responsJSON.remove("rowCount");
        	if(!responsJSON.has("rowCount")) {
            	responsJSON.put("rowCount", size);
        	}

        }
		
    	return responsJSON;
    	
    }
    
    private static JSONObject FieldsData(JSONObject responsJSON,String[] fileds)
    {
    	if(fileds.length > 0 && responsJSON.has("resultData"))
    	{
    		String select = "";
    		for(String row:fileds)
    			select += ","+row;
    		System.out.println("Select Fields => "+select.substring(1));
    		
	    	try{
	    		JSONArray jsonArray = responsJSON.getJSONArray("resultData");
	    		JSONArray newJsonArray = new  JSONArray();
	    		for(int i=0;i<jsonArray.length();i++)
	    		{
	    			try{
		    			JSONObject json = jsonArray.getJSONObject(i);
		    			JSONObject newResponse = FieldsObjectData(json,fileds);
		    			newJsonArray.put(newResponse);
		    		}catch(Exception e2)
		    		{
		    			newJsonArray.put(jsonArray.get(i));
		    		}
	    		}
	    		responsJSON.remove("resultData");
    			responsJSON.put("resultData", newJsonArray);
	    		
	    	}catch(Exception e)
	    	{
	    		try{
	    			JSONObject json = responsJSON.getJSONObject("resultData");
	    			JSONObject newResponse = FieldsObjectData(json,fileds);
	    			responsJSON.remove("resultData");
	    			responsJSON.put("resultData", newResponse);
	    		}catch(Exception e2)
	    		{
	    			//resultData not JSONObject or JSONArray
	    		}
	    		
	    	}
    	}
    	
		return responsJSON;
    	
    }    
   
    private static JSONObject FieldsObjectData(JSONObject json,String[] fileds)
    {
    	JSONObject returnData = null; 
    	if(fileds.length > 0)
    	{
    		JSONObject newResponse = new JSONObject();
        	
        	for(String row:fileds)
    		{
    			if(json.has(row))
    				newResponse.put(row, json.get(row));
    			
    		}
        	returnData = newResponse;
    	}else
    	{
    		returnData = json;
    	}
    		
    	
    	return returnData;
    }

    public static ArrayList<String> getKeyUrl(String url) {
		
		ArrayList<String> arrData = new ArrayList<String>();
		
		String[] arr = url.split("[/]");
		
		for(int i = 0; i < arr.length; i++) {
			
			if(arr[i].contains("?"))
				arr[i] = arr[i].substring(0, arr[i].indexOf("?"));
			
			if(!arr[i].equals(""))
				arrData.add(arr[i]);
		}
		
		return arrData;
		
	}
	
	public static HashMap<String, ArrayList<String>> getKeyFilter(String url) {
		
		String key = "filter=";
		String value = null;
		HashMap<String,ArrayList<String>> hashMap = new HashMap<String,ArrayList<String>>();
		
		value = url.substring(url.indexOf(key)+key.length());
		value = value.substring(0, value.indexOf(")&")+1);
		String[] array = value.split("[()]");
		
		for(int i = 0; i < array.length; i++) {
			
			String[] temp = array[i].split("=");
			
			if(temp.length > 1) {
//				System.out.println(temp[0]+" "+temp[1]);
				
				if(hashMap.containsKey(temp[0])) {
					hashMap.get(temp[0]).add(temp[1]);
				} else {
					ArrayList<String> tempArr = new ArrayList<>();
					tempArr.add(temp[1]);
					hashMap.put(temp[0], tempArr);
				}
			}
		}
		
		return hashMap;
		
	}
	
	public static String getKey(String key, String url) {
		
		key = key + "=";
		String value = "";
		
		if(url.contains(key)) {
			value = url.substring(url.indexOf(key)+key.length());
			if(value.indexOf("&") != -1)
				value = value.substring(0, value.indexOf("&"));
		}
		
		return value;
	}
	

    private static JSONObject offsetData(JSONObject responsJSON, int offset) {
    	
    	try {
    		System.out.println("Offset : " + offset);
    		JSONArray JSONArrayData = responsJSON.getJSONArray("resultData");
    		
    		int n = JSONArrayData.length();
    		
    		ArrayList<Object> offsetResultData = new ArrayList<Object>();	

    		for (int i = 0; i < n; i++)
    		{
    			if (i >= offset)
    				offsetResultData.add(JSONArrayData.get(i));
    		}
    		
    		responsJSON.remove("resultData");
    		responsJSON.put("resultData",offsetResultData);		    
    		
    	} catch (Exception e) {
			// TODO: handle exception
		}
    	
    	
    	return responsJSON;
    }

}