<?php
namespace sammo;

class Util extends \utilphp\util{
    public static function hashPassword($salt, $password){
        return hash('sha512', $salt.$password.$salt);
    }

    /**
     * 변환할 내용이 _tK_$key_ 형태로 작성된 단순한 템플릿 파일을 이용하여 결과물을 생성해주는 함수.
     */
    public static function generateFileUsingSimpleTemplate(string $srcFilePath, string $destFilePath, array $params, bool $canOverwrite=false){
        if($destFilePath === $srcFilePath){
            return 'invalid destFilePath';
        }
        if(!file_exists($srcFilePath)){
            return 'srcFilePath is not exists';
        }
        if(file_exists($destFilePath) && !$canOverwrite){
            return 'destFilePath is already exists';
        }
        if(!is_writable(dirname($destFilePath))){
            return 'destFilePath is not writable';
        }

        $text = file_get_contents($srcFilePath);
        foreach($params as $key => $value){
            $text = str_replace("_tK_{$key}_", $value, $text);
        }
        file_put_contents($destFilePath, $text);

        return true;
    }

    /**
     * '비교적' 안전한 int 변환
     * null -> null
     * int -> int
     * float -> int
     * numeric(int, float) 포함 -> int
     * 기타 -> 예외처리
     * 
     * @return int|null
     */
    public static function toInt($val, $silent=false){
        if(!isset($val)){
            return null;
        }
        if($val === null){
            return null;
        }
        if(is_int($val)){
            return $val;
        }
        if(is_numeric($val)){
            return intval($val);//
        }
        if(strtolower($val) === 'null'){
            return null;
        }

        if($silent){
            if($val == null){
                return null;
            }
            return intval($val);
        }
        throw new \InvalidArgumentException('올바르지 않은 타입형 :'.$val);
    }

    /**
     * Generate a random string, using a cryptographically secure 
     * pseudorandom number generator (random_int)
     * 
     * For PHP 7, random_int is a PHP core function
     * For PHP 5.x, depends on https://github.com/paragonie/random_compat
     * 
     * @param int $length      How many characters do we want?
     * @param string $keyspace A string of all possible characters
     *                         to select from
     * @return string
     */
    public static function randomStr($length, $keyspace = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ')
    {
        $str = '';
        $max = mb_strlen($keyspace, '8bit') - 1;
        for ($i = 0; $i < $length; ++$i) {
            $str .= $keyspace[random_int(0, $max)];
        }
        return $str;
    }

    public static function mapWithDict($callback, $dict){
        $result = [];
        foreach(array_keys($dict) as $key){
            $result[$key] = ($callback)($dict[$key]);
        }
        return $result;
    }

    public static function convertArrayToDict($arr, $keyName){
        $result = [];
    
        foreach($arr as $obj){
            $key = $obj[$keyName];
            $result[$key] = $obj;
        }
    
        return $result;
    }

    public static function convertDictToArray($dict, $keys){
        $result = [];
    
        foreach($keys as $key){
            $result[] = Util::array_get($dict[$key], null);
        }
        return $result;
    }

    public static function isDict(&$array){
        if(!is_array($array)){
            //배열이 아니면 dictionary 조차 아님.
            return false;
        }
        $idx = 0;
        $jmp = 0;
        foreach ($array as $key=>&$value) {
            if(is_string($key)){
                return true;
            }
            $jmp = $key - $idx - 1;
            $idx = $key;
        }
    
        if ($jmp * 5 >= count($array)){
            //빈칸이 많으면 dictionary인걸로.
            return true;
        }
        else{
            return false;
        }
    }

    public static function eraseNullValue($dict, $depth=512){
        //TODO:Test 추가
        if($dict === null){
            return null;
        }
    
        if(is_array($dict) && empty($dict)){
            return null;
        }
    
        if($depth <= 0){
            return $dict;
        }
    
        foreach ($dict as $key=>$value) {
            if($value === null){
                unset($dict[$key]);
            }
            else if(Util::isDict($value)){
                $newValue = Util::eraseNullValue($value, $depth - 1);
                if($newValue === null){
                    unset($dict[$key]);
                }
                else{
                    $dict[$key] = $newValue;
                }
                
            }
        }
    
        return $dict;
    }


    /** 
     * 0.0~1.0 사이의 랜덤 float
     * @return float
     */
    public static function randF(){
        return mt_rand() / mt_getrandmax();
    }

    /**
     * $prob의 확률로 true를 반환
     * @return boolean
     */
    public static function randBool($prob = 0.5){
        return self::randF() < $prob;
    }
    

    /**
     * $min과 $max 사이의 값으로 교정
     */
    public static function valueFit($value, $min, $max){
        if($value < $min){
            return $min;
        }
        if($value > $max){
            return $max;
        }
        return $value;
    }

    /**
     * 각 값의 비중에 따라 랜덤한 값을 선택
     * 
     * @param array $items 각 수치의 비중
     * 
     * @return int|string 선택된 랜덤 값의 key값. 단순 배열인 경우에는 index
     */
    public static function choiceRandomUsingWeight(array $items){
        $sum = 0;
        foreach($items as $value){
            $sum += $value;
        }

        $rd = self::randF()*$sum;
        foreach($items as $key=>$value){
            if($rd <= $value){
                return $key;
            }
            $rd -= $value;
        }

        //fallback. 이곳으로 빠지지 않음
        end($items);
        return key($items);
    }

    /**
     * 배열의 아무거나 고름. Python의 random.choice()
     * 
     * @param array $items 선택하고자 하는 배열
     * 
     * @return object 선택된 value값.
     */
    public static function choiceRandom(array $items){
        return $items[array_rand($items)];
    }

};