<?php

namespace Aiko;

use Firebase\JWT\JWT;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use finfo;

/**
 *
 */
class Http
{
	private static $request = null;
	private static $response = null;
	public static function GetBodyRequest()
	{
		self::$request = new Request();

		return self::$request->getContent();
	}

	public static function enabledCors()
	{
		// // Allow from any origin
		if (isset($_SERVER['HTTP_ORIGIN'])) {
			// Decide if the origin in $_SERVER['HTTP_ORIGIN'] is one
			// you want to allow, and if so:
			header("Access-Control-Allow-Origin: {$_SERVER['HTTP_ORIGIN']}");
			header('Access-Control-Allow-Credentials: true');
			header('Access-Control-Max-Age: 86400'); // cache for 1 day
		}

		// Access-Control headers are received during OPTIONS requests
		if ($_SERVER['REQUEST_METHOD'] == 'OPTIONS') {

			if (isset($_SERVER['HTTP_ACCESS_CONTROL_REQUEST_METHOD']))
			// may also be using PUT, PATCH, HEAD etc
			{
				header("Access-Control-Allow-Methods: GET, POST, OPTIONS");
			}

			if (isset($_SERVER['HTTP_ACCESS_CONTROL_REQUEST_HEADERS'])) {
				header("Access-Control-Allow-Headers: {$_SERVER['HTTP_ACCESS_CONTROL_REQUEST_HEADERS']}");
			}

			exit(0);
		}
	}

	public static function UnauthorizedResponse($content)
	{
		self::$response = new Response(
			$content,
			Response::HTTP_UNAUTHORIZED,
			array('content-type' => 'text/html')
		);
		self::$response->headers->set('Access-Control-Allow-Origin', '*');
		self::$response->send();
		exit();
	}

	public static function InternalServerError($content)
	{
		self::$response = new Response(
			$content,
			Response::HTTP_INTERNAL_SERVER_ERROR,
			array('content-type' => 'text/html')
		);
		self::$response->send();
		exit();
	}

	public static function UnauthorizedResponseJson($content)
	{
		self::$response = new Response(
			JWT::jsonEncode($content),
			Response::HTTP_UNAUTHORIZED,
			array('content-type' => 'application/json')
		);
		self::$response->headers->set('Access-Control-Allow-Origin', '*');
		self::$response->headers->set('Access-Control-Allow-Methods', 'POST, GET, OPTIONS, PUT, DELETE');
		self::$response->headers->set('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-Requested-With,x-firephp,x-firephp-version,x-wf-max-combined-size');
		self::$response->send();
		exit();
	}
	public static function PageNotFound($content)
	{
		self::$response = new Response(
			$content,
			Response::HTTP_NOT_FOUND,
			array('content-type' => 'text/html')
		);
		self::$response->headers->set('Access-Control-Allow-Origin', '*');
		self::$response->headers->set('Access-Control-Allow-Methods', 'POST, GET, OPTIONS, PUT, DELETE');
		self::$response->headers->set('Access-Control-Allow-Headers', 'Content-Type,Authorization,X-Requested-With,x-firephp,x-firephp-version,x-wf-max-combined-size');
		self::$response->send();

		exit();
	}

	public static function GetXsrfHeader()
	{
		self::$request   = Request::CreateFromGlobals();
		$token = self::$request->headers->get('X-XSRF-TOKEN');

		return $token;
	}

	public static function GetTokenHeader()
	{
		self::$request   = Request::CreateFromGlobals();
		$token = self::$request->headers->get('token');

		return $token;
	}

	public static function ErrorQueryResponse($content, $type = 'text')
	{
		if ($type == 'text') {
			self::$response = new Response(
				$content,
				Response::HTTP_BAD_REQUEST,
				array('content-type' => 'text/html')
			);
			self::$response->send();
		} else {
			self::$response = new JsonResponse();
			self::$response->setData($content);
			self::$response->headers->set('Access-Control-Allow-Origin', '*');
			self::$response->setStatusCode(Response::HTTP_BAD_REQUEST);
			self::$response->send();
		}

		exit();
	}

	public static function Forbidden($content, $type = 'text')
	{
		if ($type == 'text') {
			self::$response = new Response(
				$content,
				Response::HTTP_FORBIDDEN,
				array('content-type' => 'text/html')
			);
			self::$response->send();
		} else {
			self::$response = new JsonResponse();
			self::$response->setData($content);
			self::$response->headers->set('Access-Control-Allow-Origin', '*');
			self::$response->setStatusCode(Response::HTTP_FORBIDDEN);
			self::$response->send();
		}

		exit();
	}

	public static function responseJson($array, $secure = '0', $cors = '0')
	{
		if ($secure == '0') {
			self::$response = new JsonResponse();
			self::$response->setData($array);
			if ($cors == '1') {
				self::$response->headers->set('Access-Control-Allow-Origin', '*');
				self::$response->headers->set('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-Requested-With,x-firephp-version,x-firephp,x-firephp-version,x-wf-max-combined-size');
				self::$response->headers->set('Access-Control-Allow-Methods', 'POST, GET, OPTIONS, PUT, DELETE');
			}
			self::$response->send();
		} else {
			self::$response = new Response();
			$jtext    = ")]}',\n" . JWT::jsonEncode($array, JSON_UNESCAPED_SLASHES);
			self::$response->setContent($jtext);
			self::$response->headers->set('Content-Type', 'application/json');
			if ($cors == '1') {
				self::$response->headers->set('Access-Control-Allow-Origin', '*');
			}
			self::$response->send();
		}

		exit();
	}

	public static function GetVarData($key, $method = 'get')
	{
		self::$request = Request::createFromGlobals();
		if ($method == 'get') {
			$result = self::$request->query->get($key);
		} else {

			$result = self::$request->request->get($key);
		}

		return $result;
	}

	public static function Error404($content)
	{
		self::$response = new Response(
			$content,
			Response::HTTP_NOT_FOUND,
			array('content-type' => 'text/html')
		);
		self::$response->send();
		exit();
	}

	public static function GetFile($key)
	{


		self::$request = Request::createFromGlobals();
		// var_dump(self::$request);
		$result  = self::$request->files->get($key);


		return $result;
	}

	public static function CekTokenHeader()
	{
		self::$request   = Request::CreateFromGlobals();
		$token = self::$request->headers->get('token');

		return $token;
	}

	public static function CekTokenAuthHeader()
	{
		self::$request   = Request::CreateFromGlobals();
		$token = self::$request->headers->get('tokenAuth');

		return $token;
	}

	public static function getTokenJWT()
	{
		self::$request        = Request::CreateFromGlobals();
		$authHeader = self::$request->headers->get('Authorization');
		list($jwt)  = sscanf($authHeader, 'Bearer %s');
		// var_dump($jwt);
		return $jwt;
	}

	public static function getBasicAuth()
	{
		self::$request        = Request::CreateFromGlobals();
		$authHeader = self::$request->headers->get('Authorization');
		list($code)  = sscanf($authHeader, 'Basic %s');
		// var_dump($code);
		return $code;
	}

	public static function requestServer($key)
	{
		if (is_null(self::$request)) {
			self::$request = Request::CreateFromGlobals();
		}

		return self::$request->server->get($key);
	}
	public static function tokenExpired($content)
	{
		$response = new Response(
			JWT::jsonEncode($content),
			Response::HTTP_NOT_ACCEPTABLE,
			array('content-type' => 'application/json')
		);
		$response->headers->set('Access-Control-Allow-Origin', '*');
		$response->headers->set('Access-Control-Allow-Methods', 'POST, GET, OPTIONS, PUT, DELETE');
		$response->headers->set('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-Requested-With,x-firephp,x-firephp-version,x-wf-max-combined-size');
		$response->send();
		exit();
	}

	public static function responseFile($params)
	{
		$path_to_zip=$params['file_path'];


		// if( file_exists( $path_to_zip ) )
		// {
		// 	die();
		// 	header( 'Cache-Control: public' );
		// 	header( 'Content-Description: File Transfer' );
		// 	header( "Content-Disposition: attachment; filename={$path_to_zip}" );
		// 	header( 'Content-Type: application/zip' );
		// 	header( 'Content-Transfer-Encoding: binary' );
		// 	readfile( $path_to_zip );
		// 	exit;
		// }

		// die( "ERROR: invalid song or you don't have permissions to download it." );
		$extension = pathinfo(parse_url($path_to_zip, PHP_URL_PATH), PATHINFO_EXTENSION);
		$file_info = new finfo(FILEINFO_MIME_TYPE);
		$mime_type = $file_info->buffer(file_get_contents($path_to_zip));
		$file=file_get_contents($path_to_zip);

		$response = new Response(
			$file,
			Response::HTTP_OK,
			array('content-type' => $mime_type)
		);
		$response->send();

		// var_dump($file);die();
	}


    public static function getHeaderValue($key, $default = null)
    {
        self::$request  = Request::CreateFromGlobals();
        if (!self::$request->headers->has($key)) {
            return $default;
        }
		$value = self::$request->headers->has($key);
        return $value;
    }

    public static function getAllRequest($method = 'get')
	{
		self::$request = Request::createFromGlobals();
		if ($method == 'get') {
			$result = self::$request->query->all();
		} else {
			$result = self::$request->request->all();
		}
		return $result;
	}
	
	public static function isMultipartFormData()
    {
        $req   = Request::CreateFromGlobals();
        $multipart=$req->headers->has('Content-Type');
        if($multipart)
        {
            $contentType=$req->headers->get('Content-Type');
            if(strpos($contentType,'multipart/form-data')!==false)
            {
               return true;
            }
        }
        return false;
    }
}