<?php

/**
* @copyright Vertex. All rights reserved. https://www.vertexinc.com/
* @author Mediotype Development <diveinto@mediotype.com>
*/

namespace Vertex\Mapper\Api60;

use Vertex\Data\DeliveryTerm;
use Vertex\Data\FlexibleCodeFieldInterface;
use Vertex\Data\FlexibleDateFieldInterface;
use Vertex\Data\FlexibleFieldInterface;
use Vertex\Data\FlexibleNumericFieldInterface;
use Vertex\Data\LineItem;
use Vertex\Data\LineItemInterface;
use Vertex\Mapper\CustomerMapperInterface;
use Vertex\Mapper\FlexibleCodeFieldMapperInterface;
use Vertex\Mapper\FlexibleDateFieldMapperInterface;
use Vertex\Mapper\FlexibleNumericFieldMapperInterface;
use Vertex\Mapper\LineItemMapperInterface;
use Vertex\Mapper\MapperUtilities;
use Vertex\Mapper\SellerMapperInterface;
use Vertex\Mapper\TaxMapperInterface;

/**
* API Level 60 implementation of {@see LineItemMapperInterface}
* @SuppressWarnings(PHPMD.CouplingBetweenObjects)
*/
class LineItemMapper implements LineItemMapperInterface
{
/** Maximum characters allowed for commodity code */
const COMMODITY_CODE_MAX = 40;
/** Minimum characters allowed for commodity code */
const COMMODITY_CODE_MIN = 0;
/** Maximum characters allowed for commodity type code */
const COMMODITY_CODE_TYPE_MAX = 60;
/** Minimum characters allowed for commodity type code */
const COMMODITY_CODE_TYPE_MIN = 0;
/** @var int Minimum characters allowed for product code */
const PRODUCT_CODE_MAX = 40;
/** @var int Minimum characters allowed for product code */
const PRODUCT_CODE_MIN = 0;
/** @var int Maximum characters allowed for product tax class name */
const PRODUCT_TAX_CLASS_NAME_MAX = 40;
/** @var int Minimum characters allowed for product tax class name */
const PRODUCT_TAX_CLASS_NAME_MIN = 0;

/** @var CustomerMapperInterface */
private $customerMapper;

/** @var FlexibleCodeFieldMapperInterface */
private $flexibleCodeFieldMapper;

/** @var FlexibleDateFieldMapperInterface */
private $flexibleDateFieldMapper;

/** @var FlexibleNumericFieldMapperInterface */
private $flexibleNumericFieldMapper;

/** @var SellerMapperInterface */
private $sellerMapper;

/** @var TaxMapperInterface */
private $taxMapper;

/** @var MapperUtilities */
private $utilities;

/**
* @param MapperUtilities|null $utilities
* @param CustomerMapperInterface|null $customerMapper
* @param SellerMapperInterface|null $sellerMapper
* @param TaxMapperInterface|null $taxMapper
* @param FlexibleCodeFieldMapperInterface|null $flexibleCodeFieldMapper
* @param FlexibleNumericFieldMapperInterface|null $flexibleNumericFieldMapper
* @param FlexibleDateFieldMapperInterface|null $flexibleDateFieldMapper
*/
public function __construct(
MapperUtilities $utilities = null,
CustomerMapperInterface $customerMapper = null,
SellerMapperInterface $sellerMapper = null,
TaxMapperInterface $taxMapper = null,
FlexibleCodeFieldMapperInterface $flexibleCodeFieldMapper = null,
FlexibleNumericFieldMapperInterface $flexibleNumericFieldMapper = null,
FlexibleDateFieldMapperInterface $flexibleDateFieldMapper = null
) {
$this->utilities = $utilities ?: new MapperUtilities();
$this->customerMapper = $customerMapper ?: new CustomerMapper();
$this->sellerMapper = $sellerMapper ?: new SellerMapper();
$this->taxMapper = $taxMapper ?: new TaxMapper();
$this->flexibleCodeFieldMapper = $flexibleCodeFieldMapper ?: new FlexibleCodeFieldMapper();
$this->flexibleNumericFieldMapper = $flexibleNumericFieldMapper ?: new FlexibleNumericFieldMapper();
$this->flexibleDateFieldMapper = $flexibleDateFieldMapper ?: new FlexibleDateFieldMapper();
}

/**
* @inheritdoc
* @SuppressWarnings(PHPMD.CyclomaticComplexity)
* @SuppressWarnings(PHPMD.NPathComplexity)
*/
public function build(\stdClass $map)
{
$object = new LineItem();
if (isset($map->Customer)) {
$object->setCustomer($this->customerMapper->build($map->Customer));
}
if (isset($map->Seller)) {
$object->setSeller($this->sellerMapper->build($map->Seller));
}
if (isset($map->deliveryTerm)) {
$object->setDeliveryTerm($map->deliveryTerm);
}
if (isset($map->lineItemId)) {
$object->setLineItemId($map->lineItemId);
}
if (isset($map->locationCode)) {
$object->setLocationCode($map->locationCode);
}
$this->buildProduct($map, $object);

if (isset($map->ExtendedPrice)) {
$object->setExtendedPrice(
$map->ExtendedPrice instanceof \stdClass ? $map->ExtendedPrice->_ : $map->ExtendedPrice
);
}
if (isset($map->Quantity)) {
$object->setQuantity(
$map->Quantity instanceof \stdClass ? $map->Quantity->_ : $map->Quantity
);
}
if (isset($map->TotalTax)) {
$object->setTotalTax(
$map->TotalTax instanceof \stdClass ? $map->TotalTax->_ : $map->TotalTax
);
}
if (isset($map->UnitPrice)) {
$object->setUnitPrice(
$map->UnitPrice instanceof \stdClass ? $map->UnitPrice->_ : $map->UnitPrice
);
}
if (isset($map->Taxes)) {
$rawTaxes = $map->Taxes instanceof \stdClass ? [$map->Taxes] : $map->Taxes;
} else {
$rawTaxes = [];
}
if (isset($map->taxIncludedIndicator)) {
$object->setTaxIncluded($map->taxIncludedIndicator);
}
$taxes = [];
foreach ($rawTaxes as $rawTax) {
$taxes[] = $this->taxMapper->build($rawTax);
}
$object->setTaxes($taxes);
$this->buildCommodityCode($map, $object);
$this->buildFlexibleFields($map, $object);

return $object;
}

/**
* @inheritDoc
*/
public function getProductCodeMaxLength()
{
return static::PRODUCT_CODE_MAX;
}

/**
* @inheritDoc
*/
public function getProductCodeMinLength()
{
return static::PRODUCT_CODE_MIN;
}

/**
* @inheritDoc
*/
public function validateProductCode($fieldValue)
{
// TODO: Implement validateProductCode() method.
}

/**
* @inheritDoc
*/
public function getProductTaxClassNameMaxLength()
{
return static::PRODUCT_TAX_CLASS_NAME_MAX;
}

/**
* @inheritDoc
*/
public function getProductTaxClassNameMinLength()
{
return static::PRODUCT_TAX_CLASS_NAME_MIN;
}

/**
* @inheritDoc
*/
public function validateProductTaxClassName($fieldValue)
{
// TODO: Implement validateProductTaxClassName() method.
}

/**
* @inheritdoc
*/
public function map(LineItemInterface $object)
{
$map = new \stdClass();

$map = $this->utilities->addToMapWithLengthValidation(
$map,
$object->getLocationCode(),
'locationCode',
0,
20,
true,
'Location Code'
);

$map = $this->addDeliveryTermToMap($object, $map);

$map = $this->utilities->addToMapWithLengthValidation(
$map,
$object->getLineItemId(),
'lineItemId',
1,
40,
true,
'Line Item ID'
);

$this->addSellerToMap($map, $object);

$this->addCustomerToMap($object, $map);

$this->addProductToMap($object, $map);

$map = $this->utilities->addToMapWithDecimalValidation(
$map,
$object->getQuantity(),
'Quantity'
);

$map = $this->utilities->addToMapWithDecimalValidation(
$map,
$object->getUnitPrice(),
'UnitPrice',
PHP_INT_MIN,
PHP_INT_MAX,
true,
'Unit Price'
);

$map = $this->utilities->addToMapWithDecimalValidation(
$map,
$object->getExtendedPrice(),
'ExtendedPrice',
PHP_INT_MIN,
PHP_INT_MAX,
true,
'Extended Price'
);

$taxes = $object->getTaxes();
$mapTaxes = [];
foreach ($taxes as $tax) {
$mapTaxes[] = $this->taxMapper->map($tax);
}

if (!empty($mapTaxes)) {
$map->Taxes = $mapTaxes;
}

$map = $this->utilities->addToMapWithDecimalValidation(
$map,
$object->getTotalTax(),
'TotalTax',
PHP_INT_MIN,
PHP_INT_MAX,
true,
'Total Tax'
);
if ($object->isTaxIncluded() !== null) {
$map->taxIncludedIndicator = $object->isTaxIncluded();
}

$this->addCommodityToMap($map, $object);

if (count($object->getFlexibleFields())) {
$map->FlexibleFields = new \stdClass();
}
$this->mapFlexibleFields($object, $map);

return $map;
}

/**
* Add Commodity to SOAP map object
*
* @param \stdClass $map
* @param LineItemInterface $object
* @throws \Vertex\Exception\ValidationException
*/
private function addCommodityToMap(\stdClass $map, LineItemInterface $object)
{
if ($object->getCommodityCode() !== null) {
$map->CommodityCode = new \stdClass();
$map->CommodityCode = $this->utilities->addToMapWithLengthValidation(
$map->CommodityCode,
$object->getCommodityCode(),
'_',
static::COMMODITY_CODE_MIN,
static::COMMODITY_CODE_MAX,
true,
'Commodity Code'
);
if ($object->getCommodityCodeType() !== null) {
$map->CommodityCode = $this->utilities->addToMapWithLengthValidation(
$map->CommodityCode,
$object->getCommodityCodeType(),
'commodityCodeType',
static::COMMODITY_CODE_TYPE_MIN,
static::COMMODITY_CODE_TYPE_MAX,
false,
'Commodity Code Type'
);
}
}
}

/**
* Add Customer to SOAP map object
*
* @param LineItemInterface $object
* @param \stdClass $map
* @return \stdClass
* @throws \Vertex\Exception\ValidationException
*/
private function addCustomerToMap(LineItemInterface $object, \stdClass $map)
{
if ($object->getCustomer() !== null) {
$map->Customer = $this->customerMapper->map($object->getCustomer());
}
return $map;
}

/**
* Add the Delivery Term to the map
*
* @param LineItemInterface $object
* @param \stdClass $map
* @return \stdClass
* @throws \Vertex\Exception\ValidationException
*/
private function addDeliveryTermToMap(LineItemInterface $object, \stdClass $map)
{
$map = $this->utilities->addToMapWithEnumerationValidation(
$map,
$object->getDeliveryTerm(),
'deliveryTerm',
[
DeliveryTerm::CFR,
DeliveryTerm::CIF,
DeliveryTerm::CIP,
DeliveryTerm::CPT,
DeliveryTerm::CUS,
DeliveryTerm::DAF,
DeliveryTerm::DAP,
DeliveryTerm::DAT,
DeliveryTerm::DDP,
DeliveryTerm::DDU,
DeliveryTerm::DEQ,
DeliveryTerm::DES,
DeliveryTerm::EXW,
DeliveryTerm::FAS,
DeliveryTerm::FCA,
DeliveryTerm::FOB,
DeliveryTerm::SUP
],
true,
'Delivery Term'
);
return $map;
}

/**
* Add Product to SOAP map object
*
* @param LineItemInterface $object
* @param \stdClass $map
* @return \stdClass
*/
private function addProductToMap(LineItemInterface $object, \stdClass $map)
{
if ($object->getProductCode() !== null) {
$map->Product = new \stdClass();
$map->Product->_ = $object->getProductCode();
if ($object->getProductClass() !== null) {
$map->Product->productClass = $object->getProductClass();
}
}
return $map;
}

/**
* Add Seller to SOAP map object
*
* @param \stdClass $map
* @param LineItemInterface $object
* @return \stdClass
* @throws \Vertex\Exception\ValidationException
*/
private function addSellerToMap(\stdClass $map, LineItemInterface $object)
{
if ($object->getSeller() !== null) {
$map->Seller = $this->sellerMapper->map($object->getSeller());
}
return $map;
}

/**
* Map commodity code data into a LineItem
*
* @param \stdClass $map
* @param LineItem $object
* @return void
*/
private function buildCommodityCode(\stdClass $map, LineItem $object)
{
if (isset($map->CommodityCode) && $map->CommodityCode instanceof \stdClass) {
$object->setCommodityCode($map->CommodityCode->_);
if (isset($map->CommodityCode->commodityCodeType)) {
$object->setCommodityCodeType($map->CommodityCode->commodityCodeType);
}
}
}

/**
* Map Flexible Code Fields
*
* @param \stdClass $mapFields Representation of <FlexibleFields> tag
* @param FlexibleFieldInterface[] $flexibleFields
* @return FlexibleFieldInterface[]
*/
private function buildFlexibleCodeFields($mapFields, array $flexibleFields)
{
if (isset($mapFields->FlexibleCodeField)) {
if ($mapFields->FlexibleCodeField instanceof \stdClass) {
$flexibleFields[] = $this->flexibleCodeFieldMapper->build($mapFields->FlexibleCodeField);
} else {
foreach ($mapFields->FlexibleCodeField as $codeField) {
$flexibleFields[] = $this->flexibleCodeFieldMapper->build($codeField);
}
}
}
return $flexibleFields;
}

/**
* Map Flexible Date Fields
*
* @param \stdClass $mapFields Representation of <FlexibleFields> tag
* @param FlexibleFieldInterface[] $flexibleFields
* @return FlexibleFieldInterface[]
*/
private function buildFlexibleDateFields($mapFields, array $flexibleFields)
{
if (isset($mapFields->FlexibleDateField)) {
if ($mapFields->FlexibleDateField instanceof \stdClass) {
$flexibleFields[] = $this->flexibleDateFieldMapper->build($mapFields->FlexibleDateField);
} else {
foreach ($mapFields->FlexibleDateField as $dateField) {
$flexibleFields[] = $this->flexibleDateFieldMapper->build($dateField);
}
}
}
return $flexibleFields;
}

/**
* Build out flexible field items from a LineItem stdClass
*
* @param \stdClass $map
* @param LineItemInterface $object
* @return void
*/
private function buildFlexibleFields(\stdClass $map, LineItemInterface $object)
{
$flexibleFields = [];
if (isset($map->FlexibleFields)) {
$mapFields = $map->FlexibleFields;
$flexibleFields = $this->buildFlexibleCodeFields($mapFields, $flexibleFields);
$flexibleFields = $this->buildFlexibleDateFields($mapFields, $flexibleFields);
$flexibleFields = $this->buildFlexibleNumericFields($mapFields, $flexibleFields);
}

$object->setFlexibleFields($flexibleFields);
}

/**
* Map Flexible Numeric Fields
*
* @param \stdClass $mapFields Representation of <FlexibleFields> tag
* @param FlexibleFieldInterface[] $flexibleFields
* @return FlexibleFieldInterface[]
*/
private function buildFlexibleNumericFields($mapFields, array $flexibleFields)
{
if (isset($mapFields->FlexibleNumericField)) {
if ($mapFields->FlexibleNumericField instanceof \stdClass) {
$flexibleFields[] = $this->flexibleNumericFieldMapper->build($mapFields->FlexibleNumericField);
} else {
foreach ($mapFields->FlexibleNumericField as $numField) {
$flexibleFields[] = $this->flexibleNumericFieldMapper->build($numField);
}
}
}
return $flexibleFields;
}

/**
* Map product data into a LineItem
*
* @param \stdClass $map
* @param LineItem $object
* @return void
*/
private function buildProduct(\stdClass $map, LineItem $object)
{
if (isset($map->Product)) {
if ($map->Product instanceof \stdClass) {
$object->setProductCode($map->Product->_);
if (isset($map->Product->productClass)) {
$object->setProductClass($map->Product->productClass);
}
} else {
$object->setProductCode($map->Product);
}
}
}

/**
* Map Flexible Fields
*
* @param LineItemInterface $object
* @param \stdClass $map
* @return void
* @throws \Vertex\Exception\ValidationException
*/
private function mapFlexibleFields(LineItemInterface $object, \stdClass $map)
{
foreach ($object->getFlexibleFields() as $flexibleField) {
if ($flexibleField instanceof FlexibleCodeFieldInterface) {
if (!isset($map->FlexibleFields->FlexibleCodeField)) {
$map->FlexibleFields->FlexibleCodeField = [];
}
$map->FlexibleFields->FlexibleCodeField[] = $this->flexibleCodeFieldMapper->map($flexibleField);
}
if ($flexibleField instanceof FlexibleDateFieldInterface) {
if (!isset($map->FlexibleFields->FlexibleDateField)) {
$map->FlexibleFields->FlexibleDateField = [];
}
$map->FlexibleFields->FlexibleDateField[] = $this->flexibleDateFieldMapper->map($flexibleField);
}
if ($flexibleField instanceof FlexibleNumericFieldInterface) {
if (!isset($map->FlexibleFields->FlexibleNumericField)) {
$map->FlexibleFields->FlexibleNumericField = [];
}
$map->FlexibleFields->FlexibleNumericField[] = $this->flexibleNumericFieldMapper->map($flexibleField);
}
}
}
}