ImportCommand.php

<?php

namespace Ingress\Command\TikiWiki;

use Console_CommandLine;
use Ingress\Command\BaseCommand;
use Ingress\Services\Logger;
use Ingress\Services\tikiwiki\TikiWIkiConfig;
use Ingress\Services\tikiwiki\TikiWikiDB;

class ImportCommand extends BaseCommand
{

    private const MAINTENANCE_REPORT_TRACKER_MAP = [
        'rpmServiceNumber' => 'maintenanceServiceNumber',
        'rpmPersonResponsible' => 'maintenanceResponsiblePerson',
        'rpmMileage' => ['vehicleMileage', 'static::convertKM'],
        'rpmOperationalStatus' => ['vehicleOperationalStatus', 'static::convertOperationalStatus'],
        'rpmMotivation' => ['maintenanceMotivation', 'static::convertMotivation'],
        'rpmWarrantyStatus' => ['vehicleWarrantyStatus', 'static::convertWarrantyStatus'],
        'rpmOwner' => ['currentOwnwerCount', 'static::convertOwnerCount'],
        'rpmDateOfLastService' => ['lastServiceData', 'static::convertDate'],
        'rpmNextScheduledService' => ['nextScheduledService', 'static::convertDate'],
        'rpmAverageKmLInTheLastYear' => ['averageKMPerLiter', 'static::convertKMLiter'],
        'rpmMajorRepairs' => 'majorRepairsReport',
        'rpmPartsReplaced' => 'partsReplacedReport',
        'rpmServicesAndFinishes' => 'servicesAndFinishesReport',
        ];

    private static function convertKM($value) {
        // TODO implement conversion to SI
        return ["value" => $value];
    }

    private static function convertOwnerCount($value) {
        return preg_replace('/\D/', '', $value);
    }

    private static function convertDate($value) {
        // TODO implement conversion to SI
        return ["value" => $value];
    }

    private static function convertKMLiter($value) {
        // TODO implement conversion to SI
        return ["value" => $value];
    }

    private const OPERATIONAL_STATUS_MAP = [
      'no apparent issues' => 'NO_APPARENT_ISSUES',
      'maintenance required (please specify)' => 'MAINTENANCE_REQUIRED'
    ];

    private const MAINTENANCE_MOTIVATION_MAP = [
        'Periodic review' => 'PERIODIC_REVIEW',
        'Specific failure' => 'SPECIFIC_FAILURE',
        'Major failure' => 'MAJOR_FAILURE',
        'Vehicle unavailability' => 'VEHICLE_UNAVAILABILITY'
    ];

    private const WARRANTY_STATUS_MAP = [
        'Under warranty' => 'UNDER_WARRANTY',
        'Extended warranty' => 'EXTENDED_WARRANTY',
        'Out of warranty' => 'OUT_OF_WARRANTY'
    ];

    private static function convertValueMap($value, $map) {
        if (array_key_exists($value, $map)) {
            return $map[$value];
        } else {
            return null;
        }
    }

    private static function convertOperationalStatus($value) {
        return static::convertValueMap($value, static::OPERATIONAL_STATUS_MAP);
    }

    private static function convertMotivation($value) {
        return static::convertValueMap($value, static::MAINTENANCE_MOTIVATION_MAP);
    }

    private static function convertWarrantyStatus($value) {
        return static::convertValueMap($value, static::WARRANTY_STATUS_MAP);
    }


    private const MAINTENANCE_PLAN_TRACKER_FREQUENCY_MAP = [
        'vehiclemaintenancereportInspectionOfInje_tricMotor' => 'ENGINE_INSPECTION',
        'vehiclemaintenancereportSuspensionCheck' => 'SUSPENSION_CHECK',
        'vehiclemaintenancereportTransmissionFluidChange' => 'TRANSMISSION_FLUID_CHANGE',
        'vehiclemaintenancereportTimingBeltReplacement' => 'BELT_REPLACEMENT',
        'vehiclemaintenancereportSparkPlugReplacement' => 'SPARK_PLUG_REPLACEMENT',
        'vehiclemaintenancereportFrequencyForTireRotation' => 'TIRE_ROTATION',
        'vehiclemaintenancereportFrequencyForBrak_nspection' => 'BREAK_INSPECTION',
        'vehiclemaintenancereportFrequencyForFluidCheck' => 'FLUID_CHECK',
        'vehiclemaintenancereportFrequencyForComp_nspection' => 'COMPLETE_VEHICLE_INSPECTION',
        'vehiclemaintenancereportFrequencyForEmissionsTest' => 'EMISSIONS_TEST',
        'vehiclemaintenancereportBatteryTest' => 'BATTERY_TEST',
        'vehiclemaintenancereportFrequencyForOilA_terChange' => 'OIL_FILTER_CHANGE'
    ];

    private const MAINTENANCE_REPORT_SERVICE_MAP = [
        'rpmInspectionOfInjectionCombustionSystem_tricMotor' => 'ENGINE_INSPECTION',
        'rpmSuspensionCheck' => 'SUSPENSION_CHECK',
        'rpmTransmissionFluidChange' => 'TRANSMISSION_FLUID_CHANGE',
        'rpmBeltReplacement' => 'BELT_REPLACEMENT',
        'rpmSparkPlugReplacement' => 'SPARK_PLUG_REPLACEMENT',
        'rpmTireRotation' => 'TIRE_ROTATION',
        'rpmBrakeInspection' => 'BREAK_INSPECTION',
        'rpmFluidCheck' => 'FLUID_CHECK',
        'rpmEmissionsTest' => 'EMISSIONS_TEST',
        'rpmBatteryTest' => 'BATTERY_TEST',
        'rpmOilAndFilterChange' => 'OIL_FILTER_CHANGE'
    ];

    private const VEHICLE_TRACKER_MAP = [
        'vlVehicleModel' => 'signature',
        'vlYear' => 'year',
        'vlVehicleBrand' => 'model',
        'vlSignature' => 'signature',
    ];

    private const MAINTENANCE_REPORT_ERROR_CODE_MAP = [
        'ffmProblem' => 'problemDescription',
        'ffmDTCCode' => 'dtcCode'
    ];

    private const USAGE_PATTERN_MAP = [
        'personal vehicle' => 'PERSONAL_VEHICLE',
        'fleet' => 'FLEET',
        'service' => 'SERVICE'
    ];

    public static function process(array $args, array $params) {
        $domain = $args['domain'];
        $db = new TikiWikiDB();
        $trackerList = TikiWikiConfig::getTrackers($domain);
        $vehicleMap = static::importVehicles($domain, $db, $trackerList['vehicleList']);
        static::importMaintenancePlans($domain, $db, $trackerList['vehicleMaintenancePlan'], $vehicleMap);
        $maintenanceReports = static::importMaintenanceReports($domain, $db, $trackerList['vehicleMaintenanceReport'], $vehicleMap);
        $maintenanceReports = static::importMaintenanceReportsErrorCodes($domain, $db, $trackerList['vehicleMaintenanceReportErrorCodes'], $maintenanceReports);

    }

    private static function importMaintenanceReportsErrorCodes(string $domain, TikiWikiDB $db, string $trackerName, array $maintenanceReportsMap)
    {
        $maintenanceReportsErrorCodes = static::findTrackerItems($db, $trackerName);
        foreach ($maintenanceReportsErrorCodes as $maintenanceReportsErrorCode) {
            $maintenanceReportsMap = self::importMaintenanceReportsErrorCode($maintenanceReportsMap, $maintenanceReportsErrorCode);
        }
        Logger::log($maintenanceReportsMap);

        return $maintenanceReportsMap;
    }

    private static function importMaintenanceReportsErrorCode(array $maintenanceReportsMap, mixed $maintenanceReportsErrorCodeData)
    {
        $maintenanceReportsErrorCode = static::buildJson(static::MAINTENANCE_REPORT_ERROR_CODE_MAP, $maintenanceReportsErrorCodeData);
        $maintenanceReportId = $maintenanceReportsErrorCodeData['ffmVehicleMaintenanceReport']['fieldValue'];
        if (array_key_exists($maintenanceReportId, $maintenanceReportsMap)) {
            $maintenanceReportsMap[$maintenanceReportId]['vehicleFailures'][] = $maintenanceReportsErrorCode;
        }
        return $maintenanceReportsMap;
    }

    private static function importMaintenanceReports(string $domain, TikiWikiDB $db, string $trackerName, array $vehicleMap) {
        $maintenanceReportsData = static::findTrackerItems($db, $trackerName);
        $maintenanceReports = [];
        foreach ($maintenanceReportsData as $maintenanceReportDatum) {
            $maintenanceReports[$maintenanceReportDatum['tikiwikiid']] = static::importMaintenanceReport($maintenanceReportDatum, $vehicleMap);
        }
        return $maintenanceReports;
    }

    private static function importMaintenanceReport(array $maintenanceReportDatum, array $vehicleMap) {
        $maintenanceReport = static::buildJson(static::MAINTENANCE_REPORT_TRACKER_MAP, $maintenanceReportDatum);
        $maintenanceReport["vehicle"] = $vehicleMap[$maintenanceReportDatum['rpmVehicle']['fieldValue']];

        foreach ($maintenanceReportDatum as $fieldName => $field) {
            if (array_key_exists($fieldName, static::MAINTENANCE_REPORT_SERVICE_MAP)) {
                if ($field['fieldValue'] == 'y') {
                    $maintenanceReport['executedServices'][] = static::MAINTENANCE_REPORT_SERVICE_MAP[$fieldName];
                }
            }
        }

        return $maintenanceReport;
    }

    private static function importMaintenancePlans(string $domain, TikiWikiDB $db, string $trackerName, array $vehicleMap) {
        $maintenancePlansData = static::findTrackerItems($db, $trackerName);
        $maintenancePlans = [];
        foreach ($maintenancePlansData as $maintenancePlansDatum) {
            $maintenancePlan = ["vehicle" => $vehicleMap[$maintenancePlansDatum['vehiclemaintenancereportVehicle']['fieldValue']]];
            foreach ($maintenancePlansDatum as $fieldName => $field) {
                if (array_key_exists($fieldName, static::MAINTENANCE_PLAN_TRACKER_FREQUENCY_MAP)) {
                    $maintenancePlan['servicesFrequencies'][] = static::convertServiceFrequency(static::MAINTENANCE_PLAN_TRACKER_FREQUENCY_MAP[$fieldName], $field['fieldValue']);
                }
            }
            $maintenancePlans[] = $maintenancePlan;
        }
        Logger::log($maintenancePlans);
        return $maintenancePlans;
    }

    private static function convertServiceFrequency($key, $value)
    {
        // TODO calculate frequency
        return ["kind" => $key, 'internal' =>  ['value' => $value]];
    }

    private static function importVehicles(string $domain, TikiWikiDB $db, string $trackerName) {
        $vehicles = static::findTrackerItems($db, $trackerName);
        $result = [];
        foreach ($vehicles as $vehicle) {
            $result[$vehicle['tikiwikiid']] = static::importVehicle($vehicle);
        }
        Logger::log($result);
        return $result;
    }

    private static function importVehicle($vehicleTrackerData) {
        $vehicle = static::buildJson(static::VEHICLE_TRACKER_MAP, $vehicleTrackerData);
        $vehicle['usagePatterns'] = static::convertUsagePatern($vehicleTrackerData['vlUsagePatterns']['fieldValue']);
        return $vehicle;
    }

    private static function convertUsagePatern($patterns) {
        $patternList = [];

        foreach (preg_split('/,/', $patterns) as $pattern) {
            $pattern = trim($pattern);
            if (array_key_exists($pattern, static::USAGE_PATTERN_MAP)) {
                $patternList[] = static::USAGE_PATTERN_MAP[$pattern];
            }
        }

        return $patternList;
    }


    private static function findTrackerItems(TikiWikiDB $db, string $trackerName) {
        $trackerData = $db->getTrackerData($trackerName);
        return static::_extractItems($trackerData);
    }

    private static function buildJson(array $mapping, array $row): array
    {
        $result = [];

        foreach ($mapping as $fieldName => $parameters) {
            if (is_array($parameters)) {
                $jsonPath = $parameters[0];
                $convFunc = $parameters[1];
            } else {
                $jsonPath = $parameters;
            }

            if (!isset($row[$fieldName])) {
                continue; // Skip if the field is not in the row
            }

            $value = $row[$fieldName];
            $keys = explode('.', $jsonPath);
            $current = &$result;

            foreach ($keys as $key) {
                if (!isset($current[$key])) {
                    $current[$key] = [];
                }
                $current = &$current[$key];
            }

            $current = isset($convFunc) ? call_user_func($convFunc, $value['fieldValue']): $value['fieldValue'];
        }

        return $result;
    }



    private static function _extractItems(array $rows): array
    {
        $result = [];

        foreach ($rows as $row) {
            $itemId = $row['item_id'];
            $fieldName = $row['fieldName'];

            if (!isset($result[$itemId])) {
                $result[$itemId] = ['tikiwikiid' => $itemId];
            }

            $result[$itemId][$fieldName] = [
                'fieldValue' => $row['fieldValue'],
                'attachment_name' => $row['attachment_name'],
                'attachment_size' => $row['attachment_size'],
                'attachment_type' => $row['attachment_type'],
                'attachment_data' => $row['attachment_data']
            ];
        }

        return $result;
    }




    public static function register(Console_CommandLine $commandLine, array $commandMap)
    {
        $cmd = BaseCommand::addCommand($commandLine, 'tikiwiki-import', 'Imports tracker data from a domain to SmartDataContext entities',
            'Ingress\Command\TikiWiki\ImportCommand::process'
        );
        BaseCommand::addArgument($cmd, 'domain', 'Define the domain to import the data');
    }


}