/*************************************************************************
*                                                                        *
*  This file is part of the 20n/act project.                             *
*  20n/act enables DNA prediction for synthetic biology/bioengineering.  *
*  Copyright (C) 2017 20n Labs, Inc.                                     *
*                                                                        *
*  Please direct all queries to act@20n.com.                             *
*                                                                        *
*  This program is free software: you can redistribute it and/or modify  *
*  it under the terms of the GNU General Public License as published by  *
*  the Free Software Foundation, either version 3 of the License, or     *
*  (at your option) any later version.                                   *
*                                                                        *
*  This program is distributed in the hope that it will be useful,       *
*  but WITHOUT ANY WARRANTY; without even the implied warranty of        *
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
*  GNU General Public License for more details.                          *
*                                                                        *
*  You should have received a copy of the GNU General Public License     *
*  along with this program.  If not, see <http://www.gnu.org/licenses/>. *
*                                                                        *
*************************************************************************/

package com.act.biointerpretation.sars;

import act.shared.Seq;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;

import java.util.Collection;
import java.util.HashSet;
import java.util.Set;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

public class SeqDBReactionGrouperTest {

  final static private Integer SEQ_ID_A = 0;
  final static private Integer SEQ_ID_B = 1;
  final static private Integer SEQ_ID_C = 2;
  final static private String NAME_A = "SEQ_ID_0";
  final static private String NAME_B = "SEQ_ID_1";
  final static private String NAME_C = "SEQ_ID_2";
  final static private String SEQUENCE_AB = "AAA";
  final static private String SEQUENCE_C = "BBB";
  final static private Long REACTION_1 = 77L;
  final static private Long REACTION_2 = 83L;
  final static private Long REACTION_3 = 90L;
  final static private Set<Long> reactionSetA = new HashSet<>();
  final static private Set<Long> reactionSetB = new HashSet<>();
  final static private Set<Long> reactionSetC = new HashSet<>();

  static {
    reactionSetA.add(REACTION_1);
    reactionSetA.add(REACTION_2);
    reactionSetB.add(REACTION_2);
    reactionSetB.add(REACTION_3);
    reactionSetC.add(REACTION_3);
  }

  final static private String DB_NAME = "THE_DB";

  Seq mockSeqA;
  Seq mockSeqB;
  Seq mockSeqC;

  @Before
  public void init() {
    mockSeqA = Mockito.mock(Seq.class);
    Mockito.when(mockSeqA.getUUID()).thenReturn(SEQ_ID_A);
    Mockito.when(mockSeqA.getSequence()).thenReturn(SEQUENCE_AB);
    Mockito.when(mockSeqA.getReactionsCatalyzed()).thenReturn(reactionSetA);

    mockSeqB = Mockito.mock(Seq.class);
    Mockito.when(mockSeqB.getUUID()).thenReturn(SEQ_ID_B);
    Mockito.when(mockSeqB.getSequence()).thenReturn(SEQUENCE_AB);
    Mockito.when(mockSeqB.getReactionsCatalyzed()).thenReturn(reactionSetB);

    mockSeqC = Mockito.mock(Seq.class);
    Mockito.when(mockSeqC.getUUID()).thenReturn(SEQ_ID_C);
    Mockito.when(mockSeqC.getSequence()).thenReturn(SEQUENCE_C);
    Mockito.when(mockSeqC.getReactionsCatalyzed()).thenReturn(reactionSetC);
  }

  @Test
  public void testStrictSeqGrouper_CorrectSeqGroup() {
    Set<Seq> sequences = new HashSet<>();
    sequences.add(mockSeqA);
    sequences.add(mockSeqB);

    SeqDBReactionGrouper seqGrouper = new SeqDBReactionGrouper(sequences.iterator(), DB_NAME);

    int counter = 0;
    for (ReactionGroup group : seqGrouper.getReactionGroupCorpus()) {
      assertTrue("Right sequence.", group.getName().equals(NAME_A) || group.getName().equals(NAME_B));
      Collection<Long> reactionIds = group.getReactionIds();
      assertEquals("Three reaction ids", 3, reactionIds.size());
      assertTrue("Contains first reaction ID", reactionIds.contains(REACTION_1));
      assertTrue("Contains second reaction ID", reactionIds.contains(REACTION_2));
      assertTrue("Contains third reaction ID", reactionIds.contains(REACTION_3));
      counter++;
    }
    assertEquals("Only one seqGroup.", 1, counter);
  }

  @Test
  public void testStrictSeqGrouper_twoSeqGroups_rightSequences() {
    Set<Seq> sequences = new HashSet<>();
    sequences.add(mockSeqA);
    sequences.add(mockSeqB);
    sequences.add(mockSeqC);

    SeqDBReactionGrouper seqGrouper = new SeqDBReactionGrouper(sequences.iterator(), DB_NAME);

    int counter = 0;
    Set<String> outputSequences = new HashSet<>();
    for (ReactionGroup group : seqGrouper.getReactionGroupCorpus()) {
      outputSequences.add(group.getName());
      counter++;
    }

    assertEquals("Two seq groups.", 2, counter);
    assertTrue("One seq group has first sequence.",
        outputSequences.contains(NAME_A) || outputSequences.contains(NAME_B));
    assertTrue("One seq group has second sequence.", outputSequences.contains(NAME_C));
  }


  @Test
  public void testStrictSeqGrouper_AppliesLimit() {
    Set<Seq> sequences = new HashSet<>();
    sequences.add(mockSeqA);
    sequences.add(mockSeqB);
    sequences.add(mockSeqC);

    SeqDBReactionGrouper seqGrouper = new SeqDBReactionGrouper(sequences.iterator(), DB_NAME, 1);

    int counter = 0;
    for (ReactionGroup group : seqGrouper.getReactionGroupCorpus()) {
      counter++;
    }
    assertEquals("Only one seqGroup.", 1, counter);
  }


}