class OperationData

class OperationData {
    const MODE = 'mode';
    const PATH = 'path';
    const OVERWRITE = 'overwrite';
    const PREPEND = 'prepend';
    const APPEND = 'append';
    const DEFAULT = 'default';
    const FORCE_APPEND = 'force-append';
    
    /**
     * The parameter data.
     *
     * @var array
     */
    protected $data;
    
    /**
     * The destination path.
     *
     * @var string
     */
    protected $destination;
    
    /**
     * OperationData constructor.
     *
     * @param string $destination
     *   The destination path.
     * @param mixed $data
     *   The raw data array to wrap.
     */
    public function __construct($destination, $data) {
        $this->destination = $destination;
        $this->data = $this->normalizeScaffoldMetadata($destination, $data);
    }
    
    /**
     * Gets the destination path that this operation data is associated with.
     *
     * @return string
     *   The destination path for the scaffold result.
     */
    public function destination() {
        return $this->destination;
    }
    
    /**
     * Gets operation mode.
     *
     * @return string
     *   Operation mode.
     */
    public function mode() {
        return $this->data[self::MODE];
    }
    
    /**
     * Checks if path exists.
     *
     * @return bool
     *   Returns true if path exists
     */
    public function hasPath() {
        return isset($this->data[self::PATH]);
    }
    
    /**
     * Gets path.
     *
     * @return string
     *   The path.
     */
    public function path() {
        return $this->data[self::PATH];
    }
    
    /**
     * Determines overwrite.
     *
     * @return bool
     *   Returns true if overwrite mode was selected.
     */
    public function overwrite() {
        return !empty($this->data[self::OVERWRITE]);
    }
    
    /**
     * Determines whether 'force-append' has been set.
     *
     * @return bool
     *   Returns true if 'force-append' mode was selected.
     */
    public function forceAppend() {
        if ($this->hasDefault()) {
            return TRUE;
        }
        return !empty($this->data[self::FORCE_APPEND]);
    }
    
    /**
     * Checks if prepend path exists.
     *
     * @return bool
     *   Returns true if prepend exists.
     */
    public function hasPrepend() {
        return isset($this->data[self::PREPEND]);
    }
    
    /**
     * Gets prepend path.
     *
     * @return string
     *   Path to prepend data
     */
    public function prepend() {
        return $this->data[self::PREPEND];
    }
    
    /**
     * Checks if append path exists.
     *
     * @return bool
     *   Returns true if prepend exists.
     */
    public function hasAppend() {
        return isset($this->data[self::APPEND]);
    }
    
    /**
     * Gets append path.
     *
     * @return string
     *   Path to append data
     */
    public function append() {
        return $this->data[self::APPEND];
    }
    
    /**
     * Checks if default path exists.
     *
     * @return bool
     *   Returns true if there is default data available.
     */
    public function hasDefault() {
        return isset($this->data[self::DEFAULT]);
    }
    
    /**
     * Gets default path.
     *
     * @return string
     *   Path to default data
     */
    public function default() {
        return $this->data[self::DEFAULT];
    }
    
    /**
     * Normalizes metadata by converting literal values into arrays.
     *
     * Conversions performed include:
     *   - Boolean 'false' means "skip".
     *   - A string means "replace", with the string value becoming the path.
     *
     * @param string $destination
     *   The destination path for the scaffold file.
     * @param mixed $value
     *   The metadata for this operation object, which varies by operation type.
     *
     * @return array
     *   Normalized scaffold metadata with default values.
     */
    protected function normalizeScaffoldMetadata($destination, $value) {
        $defaultScaffoldMetadata = [
            self::MODE => ReplaceOp::ID,
            self::PREPEND => NULL,
            self::APPEND => NULL,
            self::DEFAULT => NULL,
            self::OVERWRITE => TRUE,
        ];
        return $this->convertScaffoldMetadata($destination, $value) + $defaultScaffoldMetadata;
    }
    
    /**
     * Performs the conversion-to-array step in normalizeScaffoldMetadata.
     *
     * @param string $destination
     *   The destination path for the scaffold file.
     * @param mixed $value
     *   The metadata for this operation object, which varies by operation type.
     *
     * @return array
     *   Normalized scaffold metadata.
     */
    protected function convertScaffoldMetadata($destination, $value) {
        if (is_bool($value)) {
            if (!$value) {
                return [
                    self::MODE => SkipOp::ID,
                ];
            }
            throw new \RuntimeException("File mapping {$destination} cannot be given the value 'true'.");
        }
        if (empty($value)) {
            throw new \RuntimeException("File mapping {$destination} cannot be empty.");
        }
        if (is_string($value)) {
            $value = [
                self::PATH => $value,
            ];
        }
        // If there is no 'mode', but there is an 'append' or a 'prepend' path,
        // then the mode is 'append' (append + prepend).
        if (!isset($value[self::MODE]) && (isset($value[self::APPEND]) || isset($value[self::PREPEND]))) {
            $value[self::MODE] = AppendOp::ID;
        }
        return $value;
    }

}