//***************************************************************
// Copyright 2008 Centre For Advanced Spatial Analysis, UCL
//
// Author: Joel Dearden, University College London
//
// Contact: j.dearden@ucl.ac.uk
//
// Joel Dearden, 
// Centre for Advanced Spatial Analysis,
// University College London,
// 1-19 Torrington Place,
// London,
// WC1E 7HB
//
//
// This file is part of PedTrace.
//
//  PedTrace is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  PedTrace is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with PedTrace.  If not, see <http://www.gnu.org/licenses/>.
//
//***************************************************************

using System;
using System.Collections;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Linq;
using pedTrace;
using System.IO;
using System.Collections.Specialized;
using System.Threading;

public partial class input : System.Web.UI.Page
{

    private Mutex fModelMutex;

    private PTModel fModel;

    
    //returns a string containing the specified query string parameter
    //returns empty string if not found
    private string GetParameter(string parameter_name)
    {

        NameValueCollection collection = Request.QueryString;

        String[] key_array = collection.AllKeys;

        if (key_array.Length > 0)
        {
            //find type
            for (int i = 0; i < key_array.Length; i++)
            {

                if (key_array[i] == parameter_name)
                {

                    //found

                    return (collection.GetValues(i))[0];
                }
            }
        }

        //not found
        return "";
    }

    private bool valid_function(string s)
    {

        //empty?
        if (s == "")
        {

            return false;
        }

        //  (function)
        //
        //  f   =  [    pi (ped in) |  
        //              pu (ped update) | 
        //              po (ped out) | 
        //              rlb (register line barrier) | 
        //              rfu (register furniture) | 
        //              rstp (register steps) | 
        //              rexd (register exit door) | 
        //              rrtd (register route door) |
        //              rfl (register floor) |
        //              rms (register model seconds) |
        //              r (reset)
        //              ]


        return  ((((s == "pi") || (s == "pu")) || ((s == "po") || (s == "rlb"))) 
                ||
                (((s == "rfu") || (s == "rstp")) || ((s == "rexd") || (s == "rrtd"))))
                ||
                (((s == "rfl") || (s == "r")) || (s == "rms"));
    }

    private bool valid_UUID(string s)
    {

        //empty?
        if (s == "")
        {

            return false;
        }

        return true;
    }

    private bool valid_float(string s)
    {

        //empty?
        if (s == "")
        {

            return false;
        }

        try
        {

            System.Convert.ToDouble(s);
        }
        catch(Exception)
        {

            return false;
        }

        return true;
    }

    private bool valid_slTime(string s)
    {

        //empty?
        if (s == "")
        {

            return false;
        }

        double time;

        try
        {

            time = System.Convert.ToDouble(s);
        }
        catch (Exception)
        {

            return false;
        }

        if (time < 0)
        {

            return false;
        }

        if (time > globals.SECONDS_PER_DAY)
        {

            return false;
        }

        return true;
    }

    
    protected void Page_Load(object sender, EventArgs e)
    {




        //if this is the first instance of the page:
        //
        //  -load the model into the application cache
        //
        //  -setup mutex
        //
        if (Cache[globals.MODEL_CACHE_NAME] == null)
        {
                                    
            PTModel ptm = new PTModel();

            Cache.Insert(globals.MODEL_CACHE_NAME, ptm);

            Mutex m = new Mutex();

            Cache.Insert(globals.MODEL_MUTEX_CACHE_NAME, m);
        }

        //retrieve model
        this.fModel = (PTModel)Cache.Get(globals.MODEL_CACHE_NAME);

        //retrieve mutex
        this.fModelMutex = (Mutex)Cache.Get(globals.MODEL_MUTEX_CACHE_NAME);



        //QUERY STRING PARAMETERS:
        //
        //
        //  //  (function)
        //
        //  f   =  [    pi (ped in) |  
        //              pu (ped update) | 
        //              po (ped out) | 
        //              rlb (register line barrier) | 
        //              rfu (register furniture) | 
        //              rstp (register steps) | 
        //              rexd (register exit door) | 
        //              rrtd (register route door) |
        //              rfl (register floor) |
        //              rms (register model seconds) |
        //              r (reset)
        //              ]
        //     
        //  (UUID)
        //  u=<string key>
        //
        //  (position.x)
        //  px=<float>
        //
        //  (position.y)
        //  py=<float>
        //
        //  (position.z)
        //  pz=<float>
        //
        //  (sltime)
        //  t=<integer>
        //
        //  (length)
        //  l=<float>
        //
        //  (orientation)
        //  o=<float>
        //
        //  (speed)
        //  s=<float>
        


        string function_param = GetParameter("f");

        string UUID_param_string = GetParameter("u");
        string positionX_string = GetParameter("px");
        string positionY_string = GetParameter("py");
        string positionZ_string = GetParameter("pz");
        string slTime_string = GetParameter("t");
        string length_string = GetParameter("l");
        string orientation_string = GetParameter("o");
        string speed_string = GetParameter("s");
        

        if (!valid_function(function_param))
        {

            //invalid function parameter - do nothing

            return;
        }


        
        //*********************************************************************
        //initially there will be no error detection or recovery in the system
        //*********************************************************************

        string UUID;
        
        float posX;
        float posY;
        float posZ;
        float orientation;
        float length;
        float speed;

        double slTime;

        //check function type
        switch (function_param)
        {

            case "rms":

                //register model second passing

                fModelMutex.WaitOne();

                fModel.modelTick();

                fModelMutex.ReleaseMutex();

                return;


            case "r":

                fModelMutex.WaitOne();

                fModel.reset();

                fModelMutex.ReleaseMutex();

                if (!valid_slTime(slTime_string))
                {

                    return;
                }

                return;

            case "pi":

                //pedestrian in

                if (!valid_UUID(UUID_param_string))
                {

                    return;
                }

                UUID = UUID_param_string;

                if (!valid_float(positionX_string))
                {

                    return;
                }

                posX = (float) System.Convert.ToDouble(positionX_string);
                
                if (!valid_float(positionY_string))
                {

                    return;
                }

                posY = (float) System.Convert.ToDouble(positionY_string);

                if (!valid_float(positionZ_string))
                {

                    return;
                }

                posZ = (float)System.Convert.ToDouble(positionZ_string);

                if (!valid_slTime(slTime_string))
                {

                    return;
                }

                slTime = System.Convert.ToDouble(slTime_string);


                fModelMutex.WaitOne();

                fModel.pedestrianIn(UUID, new PTPoint(posX, posY, posZ), slTime);

                fModelMutex.ReleaseMutex();

                return;
                
            case "pu":

                //pedestrian update

                if (!valid_float(speed_string))
                {

                    return;
                }

                speed = (float) System.Convert.ToDouble(speed_string);

                if (!valid_UUID(UUID_param_string))
                {

                    return;
                }

                UUID = UUID_param_string;

                if (!valid_float(positionX_string))
                {

                    return;
                }

                posX = (float)System.Convert.ToDouble(positionX_string);

                if (!valid_float(positionY_string))
                {

                    return;
                }

                posY = (float)System.Convert.ToDouble(positionY_string);

                if (!valid_float(positionZ_string))
                {

                    return;
                }

                posZ = (float)System.Convert.ToDouble(positionZ_string);

                if (!valid_slTime(slTime_string))
                {

                    return;
                }

                slTime = System.Convert.ToDouble(slTime_string);

                fModelMutex.WaitOne();
                
                fModel.pedestrianUpdate(UUID, new PTPoint(posX, posY, posZ), slTime, speed);

                fModelMutex.ReleaseMutex();

                return;


            case "po":

                //pedestrian out

                if (!valid_UUID(UUID_param_string))
                {

                    return;
                }

                UUID = UUID_param_string;

                if (!valid_float(positionX_string))
                {

                    return;
                }

                posX = (float)System.Convert.ToDouble(positionX_string);

                if (!valid_float(positionY_string))
                {

                    return;
                }

                posY = (float)System.Convert.ToDouble(positionY_string);

                if (!valid_float(positionZ_string))
                {

                    return;
                }

                posZ = (float)System.Convert.ToDouble(positionZ_string);

                if (!valid_slTime(slTime_string))
                {

                    return;
                }

                slTime = System.Convert.ToDouble(slTime_string);

                fModelMutex.WaitOne();

                fModel.pedestrianOut(UUID, new PTPoint(posX, posY, posZ), slTime);

                fModelMutex.ReleaseMutex();

                return;

            case "rlb":

                //register line barrier

                if (!valid_UUID(UUID_param_string))
                {

                    return;
                }

                UUID = UUID_param_string;

                if (!valid_float(positionX_string))
                {

                    return;
                }

                posX = (float)System.Convert.ToDouble(positionX_string);

                if (!valid_float(positionY_string))
                {

                    return;
                }

                posY = (float)System.Convert.ToDouble(positionY_string);

                if (!valid_float(positionZ_string))
                {

                    return;
                }

                posZ = (float)System.Convert.ToDouble(positionZ_string);

                if (!valid_float(orientation_string))
                {

                    return;
                }

                orientation = (float) System.Convert.ToDouble(orientation_string);

                if (!valid_float(length_string))
                {

                    return;
                }

                length = (float) System.Convert.ToDouble(length_string);

                fModelMutex.WaitOne();

                fModel.registerLineBarrier(UUID, new PTPoint(posX, posY, posZ), orientation, length);

                fModelMutex.ReleaseMutex();

                return;


            case "rfu":

                //register furniture

                if (!valid_UUID(UUID_param_string))
                {

                    return;
                }

                UUID = UUID_param_string;

                if (!valid_float(positionX_string))
                {

                    return;
                }

                posX = (float)System.Convert.ToDouble(positionX_string);

                if (!valid_float(positionY_string))
                {

                    return;
                }

                posY = (float)System.Convert.ToDouble(positionY_string);

                if (!valid_float(positionZ_string))
                {

                    return;
                }

                posZ = (float)System.Convert.ToDouble(positionZ_string);

                fModelMutex.WaitOne();

                fModel.registerFurniture(UUID, new PTPoint(posX, posY, posZ));

                fModelMutex.ReleaseMutex();

                return;

            case "rstp":

                //register steps

                if (!valid_UUID(UUID_param_string))
                {

                    return;
                }

                UUID = UUID_param_string;

                if (!valid_float(positionX_string))
                {

                    return;
                }

                posX = (float)System.Convert.ToDouble(positionX_string);

                if (!valid_float(positionY_string))
                {

                    return;
                }

                posY = (float)System.Convert.ToDouble(positionY_string);

                if (!valid_float(positionZ_string))
                {

                    return;
                }

                posZ = (float)System.Convert.ToDouble(positionZ_string);

                fModelMutex.WaitOne();

                fModel.registerSteps(UUID, new PTPoint(posX, posY, posZ));

                fModelMutex.ReleaseMutex();

                return;

            case "rexd":

                //register exit door

                if (!valid_UUID(UUID_param_string))
                {

                    return;
                }

                UUID = UUID_param_string;

                if (!valid_float(positionX_string))
                {

                    return;
                }

                posX = (float)System.Convert.ToDouble(positionX_string);

                if (!valid_float(positionY_string))
                {

                    return;
                }

                posY = (float)System.Convert.ToDouble(positionY_string);

                if (!valid_float(positionZ_string))
                {

                    return;
                }

                posZ = (float)System.Convert.ToDouble(positionZ_string);

                fModelMutex.WaitOne();

                fModel.registerExitDoor(UUID, new PTPoint(posX, posY, posZ));

                fModelMutex.ReleaseMutex();

                return;

            case "rrtd":

                //register route door

                if (!valid_UUID(UUID_param_string))
                {

                    return;
                }

                UUID = UUID_param_string;

                if (!valid_float(positionX_string))
                {

                    return;
                }

                posX = (float)System.Convert.ToDouble(positionX_string);

                if (!valid_float(positionY_string))
                {

                    return;
                }

                posY = (float)System.Convert.ToDouble(positionY_string);

                if (!valid_float(positionZ_string))
                {

                    return;
                }

                posZ = (float)System.Convert.ToDouble(positionZ_string);

                fModelMutex.WaitOne();

                fModel.registerRouteDoor(UUID, new PTPoint(posX, posY, posZ));

                fModelMutex.ReleaseMutex();

                return;

            case "rfl":

                //register floor

                if (!valid_float(positionZ_string))
                {

                    return;
                }

                posZ = (float)System.Convert.ToDouble(positionZ_string);

                fModelMutex.WaitOne();

                fModel.registerFloor(posZ);

                fModelMutex.ReleaseMutex();

                return;
        }
    }
}