<?php
/*
# =====================================================================
#  Projet  : darkphp
#  Fichier : DwCallBack.php
#  Auteur  : Nicolas "DarkHack" Chapuis (c) 2026
# ================== DARKHACK ==================
#        [ darkweb.fr  -  system online ]
#   Powered by Perplexity, your AI assistant
#       https://www.perplexity.ai
# ==============================================
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.
# =====================================================================
//*/
namespace darkphp;

//use darkphp\DwObject;

class DwCallBack extends DwObject
{
    public const HANDLE_STATIC_METHOD = 'static_method';
    public const HANDLE_OBJECT_METHOD = 'object_method';
    public const HANDLE_FUNCTION = 'function';

    private string $handleType;
    private $callable = null;

    private ?string $className = null;
    private ?string $methodName = null;
    private ?string $functionName = null;

    private $targetObject = null;
    private array $params = array();

    public function __construct($p1 = null, $p2 = null, ...$params)
    {
        parent::__construct(
            \is_object($p1) && \is_a($p1, \darkphp\DwObject::getStaticClassName())
                ? $p1
                : $this
        );

        if ($p1 !== null) {
            $this->bind($p1, $p2, ...$params);
        }
    }

    public function bind($p1, $p2 = null, ...$params): self
    {
        $this->params = $params;
        $this->targetObject = null;
        $this->className = null;
        $this->methodName = null;
        $this->functionName = null;
        $this->callable = null;

        if (\is_string($p1) && $p2 === null && \function_exists($p1)) {
            $this->handleType = self::HANDLE_FUNCTION;
            $this->functionName = $p1;
            $this->callable = $p1;
            return $this;
        }

        if (\is_string($p1) && \is_string($p2) && \class_exists($p1) && \method_exists($p1, $p2)) {
            $this->handleType = self::HANDLE_STATIC_METHOD;
            $this->className = $p1;
            $this->methodName = $p2;
            $this->callable = array($p1, $p2);
            return $this;
        }

        if (\is_object($p1) && \is_string($p2) && \method_exists($p1, $p2)) {
            $this->handleType = self::HANDLE_OBJECT_METHOD;
            $this->className = \get_class($p1);
            $this->methodName = $p2;
            $this->targetObject = $p1;
            $this->callable = array($p1, $p2);
            return $this;
        }

        throw new \InvalidArgumentException('Unsupported callback signature');
    }

    public function addParam($param): void
    {
        $this->params[] = $param;
    }

    public function callback(...$args)
    {
        if (!\is_callable($this->callable)) {
            throw new \RuntimeException('Callback not callable');
        }

        return \call_user_func_array(
            $this->callable,
            \array_merge($this->params, $args)
        );
    }

    public function __serialize(): array
    {
        return array(
            'handleType'   => $this->handleType,
            'className'    => $this->className,
            'methodName'   => $this->methodName,
            'functionName' => $this->functionName,
            'targetObject' => $this->targetObject,
            'params'       => $this->params,
        );
    }

    public function __unserialize(array $data): void
    {
        $this->handleType   = $data['handleType']   ?? '';
        $this->className    = $data['className']    ?? null;
        $this->methodName   = $data['methodName']   ?? null;
        $this->functionName = $data['functionName'] ?? null;
        $this->targetObject = $data['targetObject'] ?? null;
        $this->params       = $data['params']       ?? array();

        switch ($this->handleType) {
            case self::HANDLE_FUNCTION:
                $this->callable = $this->functionName;
                break;

            case self::HANDLE_STATIC_METHOD:
                $this->callable = array($this->className, $this->methodName);
                break;

            case self::HANDLE_OBJECT_METHOD:
                $this->callable = array($this->targetObject, $this->methodName);
                break;

            default:
                throw new \RuntimeException('Unknown serialized callback type');
        }

        if (!\is_callable($this->callable)) {
            throw new \RuntimeException('Unserialized callback is not callable');
        }
    }

    public function printHandle(bool $withParams = false): string
    {
        $s = '|'.$this->handleType.':';

        switch ($this->handleType) {
            case self::HANDLE_FUNCTION:
                $s .= $this->functionName;
                break;
            case self::HANDLE_STATIC_METHOD:
                $s .= $this->className.'::'.$this->methodName;
                break;
            case self::HANDLE_OBJECT_METHOD:
                $s .= $this->className.'->'.$this->methodName;
                break;
            default:
                $s .= 'unknown';
        }

        if ($withParams) {
            $s .= '(' . \count($this->params) . ' params)';
        }

        return $s . '|';
    }
}