1:   2:   3:   4:   5:   6:   7:   8:   9:  10:  11:  12:  13:  14:  15:  16:  17:  18:  19:  20:  21:  22:  23:  24:  25:  26:  27:  28:  29:  30:  31:  32:  33:  34:  35:  36:  37:  38:  39:  40:  41:  42:  43:  44:  45:  46:  47:  48:  49:  50:  51:  52:  53:  54:  55:  56:  57:  58:  59:  60:  61:  62:  63:  64:  65:  66:  67:  68:  69:  70:  71:  72:  73:  74:  75:  76:  77:  78:  79:  80:  81:  82:  83:  84:  85:  86:  87:  88:  89:  90:  91:  92:  93:  94:  95:  96:  97:  98:  99: 100: 101: 102: 103: 104: 105: 106: 107: 108: 109: 110: 111: 112: 113: 114: 115: 116: 117: 118: 119: 120: 121: 122: 123: 124: 125: 126: 127: 128: 129: 130: 131: 132: 133: 134: 135: 136: 137: 138: 139: 140: 141: 142: 143: 144: 145: 146: 147: 148: 149: 150: 151: 152: 153: 154: 155: 156: 157: 158: 159: 160: 161: 162: 163: 164: 165: 166: 167: 168: 169: 170: 171: 172: 173: 174: 175: 176: 177: 178: 179: 180: 181: 182: 183: 184: 185: 186: 187: 188: 189: 190: 191: 192: 193: 194: 195: 196: 197: 198: 199: 200: 201: 202: 203: 204: 205: 206: 207: 208: 209: 210: 211: 212: 213: 214: 215: 216: 217: 218: 219: 220: 221: 222: 223: 224: 225: 226: 227: 228: 229: 230: 231: 232: 233: 234: 235: 236: 237: 238: 239: 240: 241: 242: 243: 244: 245: 246: 247: 248: 249: 250: 251: 252: 253: 254: 255: 256: 257: 258: 259: 260: 261: 262: 263: 264: 265: 266: 

<?php

namespace DispatchModule;

/**
 * ResultSet is an envelope holding information about set of sequences
 */
class ResultSet {

    /**
     * Holds result data
     * 
     * @var array of sequences
     */
    public $data = array();

    /**
     * This count variable is important in case the partial result set is returned.
     * Gives info about the whole result set size
     * @var int
     */
    public $totalCount = 0;

    /**
     * This id variable is important for identification of experiment in case the partial result set is returned.
     * Gives info about the whole result set size
     * @var int
     */
    public $id;

    /**
     * Gives information whether intersection is required or not
     * (first call means, no intersection is required)
     * @var bool
     */
    private $first = TRUE;

    /**
     * Returns the number of the whole result set (primarly it's important when the partial result set is returned)
     * @return int Result set size
     */
    public function getTotalCount() {
        return $this->totalCount;
    }

    /**
     * Sets the result set count. This is important in case the partial result set is returned
     * @param int $totalCount Result set count
     */
    public function setTotalCount($totalCount) {
        $this->totalCount = $totalCount;
    }

    /**
     * Adds one single sequence to the result set
     *
     * @param \DispatchModule\Sequence $sequence
     */
    public function addSequence(\DispatchModule\Sequence $sequence) {
        foreach ($this->data as $seq) {
            if ($sequence->accession == $seq->accession && $sequence->startPosition == $seq->startPosition && $sequence->stopPosition == $seq->stopPosition) {
                $this->mergeSequences($seq, $sequence);
                return;
            }
        }
        $this->data[] = $sequence;
    }

    /**
     * Joins two results together
     * 
     * @param \DispatchModule\ResultSet $set
     * @param int $set Type of join (0 = intersection; 1 = right join; 2 = left join; 3 = outer join
     */
    private function join(\DispatchModule\ResultSet $set = null, $merge = 3) {
        if (is_null($set)) {
            return;
        }
        if ($this->first && empty($this->data)) {
            $this->first = FALSE;
            $this->data = $set->getData();
        } else {
            $notToMerge = array();
            $oldData = $this->data;
            $this->data = array();
            foreach ($oldData as $oldSeq) {
                $merged = false;
                foreach ($set->data as $seq) {
                    if ($seq->accession == $oldSeq->accession && $seq->startPosition == $oldSeq->startPosition && $seq->stopPosition == $oldSeq->stopPosition) {
                        $this->mergeSequences($oldSeq, $seq);
                        $this->data[] = $oldSeq;
                        $merged = true;
//                        break;
                        if (!isset($notToMerge[$seq->accession . ':' . $seq->startPosition . ':' . $seq->stopPosition])) {
                            $notToMerge[$seq->accession . ':' . $seq->startPosition . ':' . $seq->stopPosition] = $seq;
                        }
                    }
                }
                if (($merge & 2) > 0 && !$merged) {
                    $this->data[] = $oldSeq;
                }
            }
            if (($merge & 1) > 0) {
                foreach ($set->data as $seq) {
                    if (!isset($notToMerge[$seq->accession . ':' . $seq->startPosition . ':' . $seq->stopPosition])) {
                        $this->data[] = $seq;
                    }
                }
            }
        }
    }

    /**
     * Merges two results together
     * 
     * @param \DispatchModule\ResultSet $set
     */
    public function add(\DispatchModule\ResultSet $set = null) {
        $this->join($set, 3);
    }

    /**
     * Intersection of two results
     * 
     * @param \DispatchModule\ResultSet $set
     */
    public function intersect(\DispatchModule\ResultSet $set = null) {
        $this->join($set, 0);
    }

    /**
     * Add informations from $set to sequences in this ResultSet
     * 
     * @param \DispatchModule\ResultSet $set
     */
    public function leftJoin(\DispatchModule\ResultSet $set = null) {
        $this->join($set, 2);
    }

    /**
     * Returns data
     * @return array of sequences
     */
    public function getData() {
        return $this->data;
    }

    /**
     * Returns data with array containing additional info in the last key position
     * (count in the "count" key position and search identifier in the "search_id" key position)
     * 
     * @return array of sequences
     */
    public function getDataAndCount() {
        $array = $this->data;
        $last = array("count" => $this->getTotalCount());
        if (isset($this->id) && !empty($this->id)) {
            $last["search_id"] = $this->id;
        }
        $array[] = $last;
        return $array;
    }

    /**
     * Sorts the data by matches score (coverage * identity)
     */
    public function sortByScore() {
        usort($this->data, $this->build_cmpSequences());
    }

    /**
     * Return a function for comparison of two sequences according to their scores
     * @return callable comparator of sequences
     */
    private function build_cmpSequences() {
        /**
         * Compares two sequences by their matching score
         * @param \DispatchModule\Sequence $a First sequence
         * @param \DispatchModule\Sequence $b Second sequence
         * @return int Result of the comparision -1/0/1
         */
        return function (\DispatchModule\Sequence $a, \DispatchModule\Sequence $b) {
            $aScores = self::score($a);
            $bScores = self::score($b);
            for ($i=0; $i < min(count($aScores), count($bScores)); $i++) {
                if ($aScores[$i] != $bScores[$i]) {
                    return ($aScores[$i] < $bScores[$i]) ? 1 : -1;
                }            
            }
            if (count($aScores) != count($bScores)) {
                return (count($aScores) < count($bScores)) ? 1 : -1;
            }
            if (($a->stopPosition - $a->startPosition) !== ($b->stopPosition - $b->startPosition)) {
                return (($a->stopPosition - $a->startPosition) > ($b->stopPosition - $b->startPosition)) ? -1 : 1;
            }
            $res = strcmp($a->accession, $b->accession);
            if ($res !== 0) {
                return ($res < 0) ? -1 : 1;
            }
            if ($a->startPosition !== $b->startPosition) {
                return ($a->startPosition < $b->startPosition) ? -1 : 1;
            }
            if ($a->stopPosition !== $b->stopPosition) {
                return ($a->stopPosition < $b->stopPosition) ? -1 : 1;
            }
            return 0;
        };
    }

    /**
     * Select scores of matches and sort them
     * @param \DispatchModule\Sequence $sequence sequence
     * @return array sorted scores
     */
    private static function score(\DispatchModule\Sequence $sequence) {
        $scores = array();
        foreach ($sequence->matches as $match) {
            $scores[] = $match->getScore();
        }
        rsort($scores);
        return $scores;
    }

    /**
     * Sorts the matches scores in sequences (coverage * identity)
     */
    public function sortScores() {
        foreach ($this->data as $seq) {
            usort($seq->matches, array("\DispatchModule\ResultSet", "cmpMatches"));
        }
    }

    /**
     * Compares two matches by their score (coverage * identity)
     * @param \DispatchModule\BaseMatch $a First match
     * @param \DispatchModule\BaseMatch $b Second match
     * @return int Result of the comparision -1/0/1
     */
    private static function cmpMatches(\DispatchModule\BaseMatch $a, \DispatchModule\BaseMatch $b) {
        if ($a->getScore() == $b->getScore()) {
            return 0;
        }
        return ($a->getScore() < $b->getScore()) ? 1 : -1;
    }

    /**
     * Merges two sequence (sets unset properties from $newSequence into $oldSequence)
     * @param \DispatchModule\Sequence $oldSequence
     * @param \DispatchModule\Sequence $newSequence
     */
    public function mergeSequences(\DispatchModule\Sequence &$oldSequence, \DispatchModule\Sequence $newSequence) {
        // get properties of newSequence as array
        $params = get_object_vars($newSequence);

        foreach ($params as $propertyName => $propertyValue) {
            if (is_null($oldSequence->$propertyName) || empty($oldSequence->$propertyName)) {
                $oldSequence->$propertyName = $propertyValue;
            } else if (is_array($oldSequence->$propertyName) &&  isset($newSequence->$propertyName)
                                                             && !empty($newSequence->$propertyName)) {
                $oldSequence->$propertyName = array_merge($oldSequence->$propertyName, $newSequence->$propertyName);
            }
        }
    }

}