package sourcecode.MockUp;

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.net.URLDecoder;
import java.util.ArrayList;

import org.apache.commons.io.IOUtils;
import org.apache.http.Consts;
import org.bson.Document;
import org.json.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 String DBNAME = "spw";
	private static String DBHOST = "10.1.2.155:27017";
	
	public static void main(String[] args) throws Exception {
		
		int port = 6300;
		try {
			if(args.length>0)
				port = Integer.parseInt(args[0]);
			
			if(args.length>1)
				DBNAME = args[1];
			
			if(args.length>2)
				DBHOST = args[2];
			
	        //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 {
        public void handle(HttpExchange t) throws IOException {
        	
        	String method = t.getRequestMethod();        	
        	String url = t.getRequestURI().toString();
        	url = URLDecoder.decode(url, "UTF-8");
        	String response = "";
        	String keyBody ="";

//        	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 collectionName = getSuffixTableName(url);
        	
        	BasicDBObject basicDBObject = new BasicDBObject();
        	
        	switch (method) {
			case GET:
				basicDBObject.put("url", url);
				break;
			case POST:
			case PUT:
				basicDBObject.put("key", keyBody);
				break;
			case DELETE:
				basicDBObject.put("key", url);
				break;
			
			default:
				break;
			}
        	
        	ArrayList<String> responseList = getDBData(basicDBObject,collectionName,method);
        	
        	if(responseList.size() == 0)
        	{
        		System.out.println("===> Go to Main flow");   
        		
        		BasicDBObject basicDBObjectMain = new BasicDBObject();
        		if(method.equals(GET))
        			basicDBObjectMain.put("url", "");
        		else
        			basicDBObjectMain.put("key", "");
        		responseList = getDBData(basicDBObjectMain,collectionName,method);
        		
        		
        	}
        	
        	JSONObject responsJSON = new JSONObject();
    		ArrayList<JSONObject> resultData = new ArrayList<JSONObject>();
        	for(int i=0;i<responseList.size();i++)
        	{
        		
        		JSONObject rowJSON = new JSONObject(responseList.get(i)); 
        		
        		if(responseList.size() > 1)
        		{
        			if(rowJSON.get("resultData")!=null)
        				resultData.add((JSONObject) rowJSON.get("resultData"));
        			else if(rowJSON.get("value")!=null)
        				resultData.add((JSONObject) rowJSON.get("value"));
        		}else
        			resultData.add((JSONObject) rowJSON.get("resultData"));
        		System.out.println("aa" + rowJSON);
//        		resultData.add((JSONObject) rowJSON.get("resultData"));            		
        	}
    		
    		
    		responsJSON.put("resultCode", "20000");
    		responsJSON.put("resultDescription", "Success");
    		if(method.equals(GET))
    		{
        		responsJSON.put("resultData",resultData);
        		responsJSON.put("rowCount", resultData.size());
    		}
    		
//    		System.out.println(responsJSON.toString());
    		response = responsJSON.toString();
        	
        	
        	t.getResponseHeaders().set("Content-Type", "application/json");
        	t.sendResponseHeaders(200, response.length());
        	OutputStream os = t.getResponseBody();
            os.write(response.getBytes());
            os.close();
            
            System.out.println("");
            System.out.println("URL : " + url);
            System.out.println("Method : " + method);
            System.out.println("Response : " + response);
            System.out.println("");
        }
    }
    
    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;
		    }
		}
		return value;
	}

   
    private static void MongoConnector(String db) {
    	
    	String username = "";
		String password = "";
		String address = DBHOST;
		String dbname = db;
		String authSource = db;
		int timeoutMongoDB = 10000;		
		
		 MongoClientOptions.Builder optionsBuilder = MongoClientOptions.builder(); 
			optionsBuilder.connectTimeout(timeoutMongoDB); 
			optionsBuilder.socketTimeout(timeoutMongoDB); 
			optionsBuilder.serverSelectionTimeout(timeoutMongoDB);

//			optionsBuilder.connectionsPerHost(maxPoolSize);
//			optionsBuilder.minConnectionsPerHost(minPoolSize);
	        
	        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(BasicDBObject basicDBObject,String collectionName,String method)
    {
    	collectionName = method.toLowerCase()+"_"+collectionName;
    	System.out.println("CollectionName : " + collectionName);
    	System.out.println("Find : "+basicDBObject.toJson());
    	ArrayList<String> returnData = new ArrayList<String>();
    	String found = "";
    	
    	MongoCollection<Document> collection = database.getCollection(collectionName);
    	FindIterable<Document> findData = collection.find(basicDBObject);
    	MongoCursor<Document> cursor = findData.iterator();
    	
    	
    	switch (method) {
		case GET:
			while(cursor.hasNext()){
				Document rawRow = cursor.next(); 
				System.out.println("found _id : "+rawRow.get("_id"));
				rawRow.remove("_id");
				rawRow.remove("url");
				if(rawRow.get("value") != null)
				{
					
					rawRow.append("resultData", rawRow.get("value"));
					rawRow.append("rowCount", "1");
					rawRow.remove("value");
				}
				found = rawRow.toJson();
				returnData.add(found);
			}			
			break;
		case POST:
		case PUT:
		case DELETE:
			while(cursor.hasNext()){
				Document rawRow = cursor.next(); 
				System.out.println("found _id : "+rawRow.get("_id"));
				rawRow.remove("_id");
				rawRow.remove("key");
				if(rawRow.get("value") != null)
				{
					
					JSONObject rowJSON = new JSONObject(rawRow.toJson()); 
//					System.out.println(rowJSON.get("value"));
					found = rowJSON.get("value").toString();
					returnData.add(found);
					System.out.println("found : "+found);
				}else
				{
					found = rawRow.toJson();
					returnData.add(found);
				}
				
			}			
			break;

		default:
			break;
		}
    	
    	
    	return returnData;
    }
}