<?php

class MediaHelper
{
    const FIELD_FOTO            = "foto";
    const FIELD_PRESIGNED_URL   = "presigned_url";
    const FIELD_PRESIGNED_EXP   = "presigned_exp";

    public static function fileResponse($filename, $humanFilename = null, $setMime = true, $isInline = false)
    {
        $response = new Phalcon\Http\Response();
        if ($setMime) {
            $response->setContentType(mime_content_type($filename));
        }
        $response->setContent(file_get_contents($filename));

        if (!empty($humanFilename)) {
            if($isInline)
                $response->setHeader('Content-Disposition', "inline; filename=\"" . $humanFilename . "\"");
            else
                $response->setHeader('Content-Disposition', "attachment; filename=\"" . $humanFilename . "\"");
        }
        return $response;
    }

    public static function getPublicPath($baseUrl, $filename)
    {
        if (empty($filename)) {
            return "";
        } elseif (strlen($filename) > 6 && substr($filename, 0, 4) === "http") {
            return $filename;
        } else {
            return $baseUrl . $filename;
        }
    }

    public static function getUrl($filename, $config, MinioService $service)
    {
        if ($filename == null ||$filename == '' || $filename == '-') {
            return null;
        }

        if (getenv("FILESYSTEM_CLOUD") == FileSystemCloud::MINIO) {
            $filekey = 'users_profpic' . DIRECTORY_SEPARATOR . $filename;
            $url = null;
            if ($service->isSecondaryS3Available() && $service->isFileExistNoLog($filekey, true, false)) {
                $url = $service->basePublicUrlUsingSecondaryS3($filekey, $filename, false, MinioService::LONG_EXPIRED_DURATION);
            } elseif ($service->isFileExistNoLog($filekey)) {
                $url = $service->base_get_public_url($filekey, $filename, false, MinioService::LONG_EXPIRED_DURATION);
            }
            return $url;
        } elseif (getenv("FILESYSTEM_CLOUD") == FileSystemCloud::LOCAL) {
            return MediaHelper::getPublicPath($config["profile_picture_base_url"], $filename);
        }
    }

    public static function getPresignedUrlFoto(array $data, $model, $config, MinioService $service)
    {
        try {
            if (getenv("FILESYSTEM_CLOUD") == FileSystemCloud::MINIO) {
                if (!self::isPresignedFieldExist($data, array(self::FIELD_FOTO))) {
                    return null;
                }

                $newExpiration = (new DateTime())->modify("+".MinioService::LONG_EXPIRED_DURATION)->format('Y-m-d H:i:s');
                if (self::isPresignedFieldExist($data)) {
                    $presignedExp = $data[self::FIELD_PRESIGNED_EXP];
                    $isExpired = self::checkIsExpired($presignedExp);
                    if ($isExpired) {
                        $url = self::getUrl($data[self::FIELD_FOTO], $config, $service);
                        self::savePresignedInfo(
                            $model,
                            $data[$model::$pkey],
                            [
                                self::FIELD_PRESIGNED_URL => $url,
                                self::FIELD_PRESIGNED_EXP => $newExpiration
                            ]
                        );
                    } else {
                        $url = $data[self::FIELD_PRESIGNED_URL];
                    }
                } else {
                    $url = self::getUrl($data[self::FIELD_FOTO], $config, $service);
                    self::savePresignedInfo(
                        $model,
                        $data[$model::$pkey],
                        [
                            self::FIELD_PRESIGNED_URL => $url,
                            self::FIELD_PRESIGNED_EXP => $newExpiration
                        ]
                    );
                }
                return $url;
            } elseif (getenv("FILESYSTEM_CLOUD") == FileSystemCloud::LOCAL) {
                $filename = $data["foto"];
                return MediaHelper::getPublicPath($config["profile_picture_base_url"], $filename);
            }
        } catch (\Exception $e) {
            return null;
        }
    }

    public static function isPresignedFieldExist(array $array, $fields = array()): bool
    {
        if (empty($fields)) {
            $fields = [self::FIELD_PRESIGNED_URL, self::FIELD_PRESIGNED_EXP];
        }
        foreach ($fields as $field) {
            if (!array_key_exists($field, $array) || empty($array[$field]) || $array[$field] == '-') {
                return false;
            }
        }
        return true;
    }

    public static function savePresignedInfo($model, $pkeyValue, array $info) {
        $pkey = $model::$pkey;
        $row = $model::findFirst(["conditions" => "$pkey = :pkey:", "bind" => ["pkey" => $pkeyValue]]);
        if ($row) {
            $fields = [self::FIELD_PRESIGNED_URL, self::FIELD_PRESIGNED_EXP];
            foreach ($fields as $field) {
                $row->$field = $info[$field];
            }
            $row->save();
        }
    }

    public static function checkIsExpired($date) {
        try {
            $exp = new DateTime($date);
            $now = new DateTime();
            $now = $now->modify('+10 minutes');
            $isExpired = $exp < $now;
        } catch (\Exception $e) {
            $isExpired = true;
        }

        return $isExpired;
    }
}