<?php
namespace SmartData\SmartAPI
{
    require_once( __DIR__ . '/Logger.php');
    require_once( __DIR__ . '/Backend.php');
    require_once( __DIR__ . '/Packer.php');

    use SmartData\SmartAPI\Internals\{JsonAPI, BinaryAPI};
    use SmartData\Exception\{BadRequestException, RequestFailedException, InsertionFailedException, CreationFailedException};
    use SmartData\{Series, SmartData, Backend, Logger};
    use SmartData\Utility\{Pack,Unpack};

    function health_check()
    {
        return Backend::health_check();
    }

    function get($content)
    {
        $json = json_decode($content, false, 512, JSON_BIGINT_AS_STRING);
        if (json_last_error() === JSON_ERROR_NONE)
            list($credentials,$series,$aggregator,$options) = JsonAPI::parse_get($json);
        else
            list($credentials,$series,$aggregator,$options) = BinaryAPI::parse_get($content);

        if ($series instanceof Series) {
            $backend = new Backend($credentials);

            switch($series->version) {
            case SmartData::STATIC_VERSION:
                $return = $backend->query($series,$aggregator,$options);
                break;
            case SmartData::MOBILE_VERSION:
                $return = $backend->track($series,$aggregator,$options);
                break;
            default:
                throw new \Exception("Unsupported SmartData version [{$ver}]");
                return null;
            }

            if($return != NULL){
                $return = json_encode($return);
                $return = preg_replace('/:"([0-9]*)"/',':$1',$return);
            } else {
                throw new RequestFailedException("Error processing request: null return");
            }
        } else {
            throw new BadRequestException("Error parsing content request: invalid series");
        }

        return $return;
    }

    function put($content)
    {
        $json = json_decode($content, false, 512, JSON_BIGINT_AS_STRING);
        if (json_last_error() === JSON_ERROR_NONE)
            list($credentials,$smartdata_array,$params) = JsonAPI::parse_put($json);
        else
            list($credentials,$smartdata_array,$params) = BinaryAPI::parse_put($content);

        $backend = new Backend($credentials);

        foreach($smartdata_array as $smartdata) {
            //if(REQUEST_CERT == 'A7B64D415BD3E97B' && $smartdata->unit()->is_digital())
                //Logger::debug('smartlisha: '.$smartdata, true);

            //if($smartdata->unit == 2224466212)
            //    Logger::debug('vibration: '.$smartdata, true);
            //if($smartdata->unit == 2224199972)
            //    Logger::debug('sound: '.$smartdata, true);
            if($smartdata->unit == 6488072){
                //Logger::debug('mmmmmm: '.$smartdata, true);
                //Logger::var_dump($smartdata->value, true);

                //$value = $json->smartdata[0]->value;
                //Logger::debug('json:  '.$value, true);
                //$value = base64_decode($value);
                //Logger::debug('decoded:  '.$value, true);
                //Logger::debug('hex:  '.bin2hex($value), true);
                //Logger::debug('uint:  '.Unpack::d64($value), true);

                //$v = Unpack::d64($smartdata->value);
                //Logger::debug('::'.$v, true);
            }
            //if($smartdata->unit == 196612)
            //    Logger::debug('CARD_READER::: '.$smartdata, true);
            //else if($smartdata->unit == 2224180004 && false)
            //    Logger::debug('POWER::: '.$smartdata, true);
            //else if($smartdata->unit == 262148)
            //    Logger::debug('DOOR::: '.$smartdata, true);
            //else if(false)
            //    Logger::debug('SmartData: '.$smartdata, true);
	    //Logger::time_elapsed(true);
            if(!$backend->insert($smartdata, ...$params)) {
                throw new InsertionFailedException("Insertion Failed");
            }
	    //Logger::time_elapsed();
        }
    }

    function create($content)
    {
        $json = json_decode($content, false, 512, JSON_BIGINT_AS_STRING);
        if (json_last_error() === JSON_ERROR_NONE)
            list($credentials,$series,$params) = JsonAPI::parse_create($json);
        else
            list($credentials,$series,$params) = BinaryAPI::parse_create($content);

        if ($series instanceof Series) {
            Logger::debug("series ".$series, true);

            $backend = new Backend($credentials);
            if(!$backend->create($series, ...$params)){
                throw new CreationFailedException("Creation Failed");
            }
        } else {
            throw new BadRequestException("Error parsing content request: invalid series");
        }
    }

    function attach($content)
    {
        $json = json_decode($content, false, 512, JSON_BIGINT_AS_STRING);
        if (json_last_error() === JSON_ERROR_NONE)
            list($credentials,$series,$params) = JsonAPI::parse_attach($json);
        else
            list($credentials,$series,$params) = BinaryAPI::parse_attach($content);

        if ($series instanceof Series) {
            $backend = new Backend($credentials);
            if(!$backend->attach($series, ...$params)){
                throw new CreationFailedException("Attachment Failed");
            }
        } else {
            throw new BadRequestException("Error parsing content request: invalid series");
        }
    }

    function batch($content)
    {
        $json = json_decode($content, false, 512, JSON_BIGINT_AS_STRING);
        if (json_last_error() === JSON_ERROR_NONE)
            throw new Exception\NotImplementedException("JSON-based import in batch has not been implemented yet");
        else{
            //list($credentials,$smartdata_array,$params) = BinaryAPI::parse_put($content);
            $binary = $content;
            $credentials = null;
            if(!REQUEST_CERT){
                $credentials = Credentials::unpack($binary);
                if(!$credentials){
                    throw new BadRequestException("!CERT > Credentials cannot be null");
                }
                Logger::debug("sem CRT", true);
            }else{
                Logger::debug("com CRT", true);
            }

            $series = Series::unpack($binary);

            $csdf = array();
            $smartdata_array = array();
            while($binary) {
                $smartdata = SmartData::unpack($binary, $csdf);
                //Logger::debug($smartdata, true);
                if($smartdata instanceof SmartData)
                    array_push($smartdata_array, $smartdata);
            }
            $params = array();

            $backend = new Backend($credentials);
            if(!$backend->insertBatch($series, ...$smartdata_array)) {
                Logger::debug("failure", true);
                throw new Exception\InsertionFailedException("Insertion Failed");
            }
        }
    }
}

namespace SmartData\SmartAPI\Internals
{
    use SmartData\{Series,SmartData,Credentials,Logger};

    trait JsonAPI
    {
        public function parse_get($json)
        {
            $credentials = null;
            if(isset($json->credentials))
                $credentials = Credentials::fromJson($json->credentials);
            $series      = Series::fromJson($json->series);
            $aggregator  = $json->aggregator ?? null;
            $options     = $json->options?? null;
            return array($credentials, $series, $aggregator, $options);
        }

        public function parse_put($json)
        {
            ////Logger::debug('JsonAPI', true);
            $credentials = null;
            $params = $smartdata_array = array();
            if(isset($json->credentials))
                $credentials = Credentials::fromJson($json->credentials);
            $smartdata_set = $json->smartdata;
            foreach($smartdata_set as $smartdata_fields) {
                $smartdata = SmartData::fromJson($smartdata_fields);
                if($smartdata instanceof SmartData)
                    array_push($smartdata_array, $smartdata);
            }
            return array($credentials, $smartdata_array, $params);
        }

        public function parse_create($json)
        {
            ////Logger::debug('JsonAPI', true);
            $credentials = null;
            $params = array();
            if(isset($json->credentials))
                $credentials = Credentials::fromJson($json->credentials);
            $series      = Series::fromJson($json->series);
            $aggregator  = array($json->aggregator??null);
            return array($credentials, $series, $params);
        }

        public function parse_attach($json)
        {
            ////Logger::debug('JsonAPI', true);
            $credentials = null;
            $params = array();
            if(isset($json->credentials))
                $credentials = Credentials::fromJson($json->credentials);
            $series      = Series::fromJson($json->series);
            $aggregator  = array($json->aggregator??null);
            return array($credentials, $series, $params);
        }
    }
}

namespace SmartData\SmartAPI\Internals
{
    use SmartData\Exception\{BadRequestException};
    use SmartData\{Series,SmartData,Credentials,Logger};
    use SmartData\Utility\{Unpack};

    trait BinaryAPI
    {
        public function parse_get($binary)
        {
            //Logger::debug('BinaryAPI', true);
            $credentials = null;
            $series = Series::unpack($binary);
            $params = array();
            $options = array();
            return array($credentials, $series, $params, $options);
        }

        public function parse_put($binary)
        {
            //Logger::debug('BinaryAPI', true);
            $credentials = null;
            if(!REQUEST_CERT){
                $credentials = Credentials::unpack($binary);
                if(!$credentials){
                    throw new BadRequestException("!CERT > Credentials cannot be null");
                }
            }

            // Common SmartData Fields Bitmap
            // ------7-----------6-----------5-----------4-----------3-----------2-----------1-----------0-------
            // |  version  |    unit   |   error   | confidence |    x     |     y     |     z     |    dev     |
            // --< 1 bit >---< 1 bit >---< 1 bit >---< 1 bit >---< 1 bit >---< 1 bit >---< 1 bit >---< 1 bit >---
            $csdf = array();
            if(isset($_GET['csdf'])){
                $csdf_bitmap = intval($_GET['csdf']);
                if(($csdf_bitmap & (0b1 << 7)) != 0) $csdf = array_merge($csdf, array('version'    => Unpack::uInt8($binary,  true)));
                if(($csdf_bitmap & (0b1 << 6)) != 0) $csdf = array_merge($csdf, array('unit'       => Unpack::uInt32($binary, true)));
                if(($csdf_bitmap & (0b1 << 5)) != 0) $csdf = array_merge($csdf, array('error'      => Unpack::uInt8($binary,  true)));
                if(($csdf_bitmap & (0b1 << 4)) != 0) $csdf = array_merge($csdf, array('confidence' => Unpack::uInt8($binary,  true)));
                if(($csdf_bitmap & (0b1 << 3)) != 0) $csdf = array_merge($csdf, array('x'          => Unpack::int32($binary,  true)));
                if(($csdf_bitmap & (0b1 << 2)) != 0) $csdf = array_merge($csdf, array('y'          => Unpack::int32($binary,  true)));
                if(($csdf_bitmap & (0b1 << 1)) != 0) $csdf = array_merge($csdf, array('z'          => Unpack::int32($binary,  true)));
                if(($csdf_bitmap & (0b1 << 0)) != 0) $csdf = array_merge($csdf, array('dev'        => Unpack::uint32($binary, true)));
            }

            $smartdata_array = array();
            while($binary) {
                $smartdata = SmartData::unpack($binary, $csdf);
                if($smartdata instanceof SmartData)
                    array_push($smartdata_array, $smartdata);
            }
            $params = array();
            return array($credentials, $smartdata_array, $params);
        }

        public function parse_create($binary)
        {
            //Logger::debug('BinaryAPI', true);
            $credentials = null;
            if(!REQUEST_CERT){
                $credentials = Credentials::unpack($binary);
                if(!$credentials){
                    throw new BadRequestException("!CERT > Credentials cannot be null");
                }
            }
            $series = Series::unpack($binary);
            $params = array();
            return array($credentials, $series, $params);
        }

        public function parse_attach($binary)
        {
            //Logger::debug('BinaryAPI', true);
            $credentials = null;
            if(!REQUEST_CERT){
                $credentials = Credentials::unpack($binary);
                if(!$credentials){
                    throw new BadRequestException("!CERT > Credentials cannot be null");
                }
            }
            $series = Series::unpack($binary);
            $params = array();
            return array($credentials, $series, $params);
        }
    }
}