* Copyright 2013, The Sporting Exchange Limited

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

*     http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

    public static final String SONIC_TRANSPORT_INSTANCE_ONE="SonicEventTransportImpl:firstSonicInstance";

    private ExecutionObserver timeTickPublishingObserver;

    private ExecutionObserver matchedBetObserver;

    private ExecutionObserver logMessageObserver;

    private ExecutionObserver listMessageObserver;

    private ExecutionObserver setMessageObserver;

    private ExecutionObserver mapMessageObserver;

    private Map<String, ExecutionObserver> longEventNamespacedExecutionObserver = new ConcurrentHashMap<String, ExecutionObserver>();

    private BaselineSyncClient baselineAsClient;

    private BaselineClient baselineAsyncClient;

    private BaselineSyncClient inProcessSyncClient;

    private BaselineSyncClient socketSyncClient;

  private MonitorRegistry monitorRegistry;

    private AbstractLoggingControl loggingControl;

  final static CougarLogger LOGGER = CougarLoggingUtils.getLogger(BaselineServiceImpl.class);

    private List<TimeTick> timeTicks = new ArrayList<TimeTick>();

    private List<MatchedBet> matchedBets = new ArrayList<MatchedBet>();

    private List<LogMessage> logMessages = new ArrayList<LogMessage>();

    private List<ListEvent> listEvents = new ArrayList<ListEvent>();

    private List<SetEvent> setEvents = new ArrayList<SetEvent>();

    private List<MapEvent> mapEvents = new ArrayList<MapEvent>();

    private Set<String> subscriptionsBeingCreated = new HashSet<String>();

    private Map<String, Subscription> pubsubSubscriptions = new ConcurrentHashMap<String, Subscription>();

    private Map<String, List<Subscription>> heapSubscriptions = new ConcurrentHashMap<String, List<Subscription>>();

    private Heap simpleConnectedObjectHeap = new MutableHeap("simpleConnectedObject");

    private Heap simpleConnectedListHeap = new MutableHeap("simpleConnectedList");

    private Heap complexConnectedObjectHeap = new MutableHeap("complexConnectedObject");

    private List<CountDownLatch> outstandingSleeps = new CopyOnWriteArrayList<CountDownLatch>();

    private String instance;

    public void setLoggingControl(AbstractLoggingControl loggingControl) {

        this.loggingControl = loggingControl;

    }

    public void setBaselineAsClient(BaselineSyncClient baselineAsClient) {

        this.baselineAsClient = baselineAsClient;

    }

    public void setBaselineAsyncClient(BaselineClient baselineAsyncClient) {

        this.baselineAsyncClient = baselineAsyncClient;

    }

    public void setInProcessSyncClient(BaselineSyncClient inProcessSyncClient) {

        this.inProcessSyncClient = inProcessSyncClient;

    }

    public void setSocketSyncClient(BaselineSyncClient socketSyncClient) {

        this.socketSyncClient = socketSyncClient;

    }

    @Override

    public void init(ContainerContext cc) {

        //cc.addProcessingHandlers(handlers);

        cc.registerExtensionLoggerClass(BaselineLogExtension.class, 3);

        cc.registerConnectedObjectExtensionLoggerClass(BaselineLogExtension.class, 3);

        //cc.setAnonymousAccessAllowed(true); // defaults to true

        monitorRegistry = cc.getMonitorRegistry();

        monitorRegistry.addMonitor(new BaselineMonitor("DB"+instance, Status.OK));

        monitorRegistry.addMonitor(new BaselineMonitor("Cache"+instance, Status.OK));

        monitorRegistry.addMonitor(new BaselineMonitor("Service"+instance, Status.OK));

  }

    @Override

    public String echoCougarPropertyValue(RequestContext ctx, String propertyName, TimeConstraints timeConstraints){

        ctx.setRequestLogExtension(new BaselineLogExtension(propertyName, null, null));

        final Map<String,String> props = PropertyConfigurer.getAllLoadedProperties();

        return props.get(propertyName);

    }

    @Override

    public void interceptorCheckedExceptionOperation(RequestContext ctx, PreOrPostInterceptorException preOrPostException, TimeConstraints timeConstraints) throws SimpleException {

        //Null implementation as this method is used as part of a test for pre/post checked service defined exception handling

        ctx.setRequestLogExtension(new BaselineLogExtension(preOrPostException, null, null));

    }

   

  @Override

  public void listOfComplexOperation(RequestContext ctx, List<ComplexObject> inputList, TimeConstraints timeConstraints) throws SimpleException {

   

    ctx.setRequestLogExtension(new BaselineLogExtension(inputList.toArray(), null, null));

  }

  @Override

  public void setOfComplexOperation(RequestContext ctx, Set<ComplexObject> inputSet, TimeConstraints timeConstraints) throws SimpleException {

   

    ctx.setRequestLogExtension(new BaselineLogExtension(inputSet.toArray(), null, null));   

  }

  @Override

  public void mapOfComplexOperation(RequestContext ctx, Map<String, ComplexObject> inputMap, TimeConstraints timeConstraints) throws SimpleException {

   

    ctx.setRequestLogExtension(new BaselineLogExtension(inputMap.toString(), null, null));

  }

    @Override

    public void mandatoryCollectionElementTest ( RequestContext ctx , List<ComplexObject> inputList, Map<String, ComplexObject> inputMap, TimeConstraints timeConstraints)

    throws SimpleException

    {

        ctx.setRequestLogExtension(new BaselineLogExtension(inputList.toArray(), inputMap.toString(), null));

    }

    @Override

    public List<Date> testSimpleDateListGet ( RequestContext ctx , List<Date> inputList, TimeConstraints timeConstraints)

            throws SimpleException

    {

        ctx.setRequestLogExtension(new BaselineLogExtension(inputList.toArray(), null, null));

        return new ArrayList<Date>(inputList);

    }

   

    @Override

     public Map<String,String> testSimpleMapGet ( RequestContext ctx , Map<String,String> inputMap, TimeConstraints timeConstraints)

             throws SimpleException

     {

         ctx.setRequestLogExtension(new BaselineLogExtension(inputMap.entrySet(), null, null));

         Map<String, String> result = new HashMap<String, String>();

         result.putAll(inputMap);

         return result;

     }

    @Override

    public Set<String> testSimpleSetGet ( RequestContext ctx , Set<String> inputSet, TimeConstraints timeConstraints)

            throws SimpleException

    {

        ctx.setRequestLogExtension(new BaselineLogExtension(inputSet.toArray(), null, null));

        return new HashSet<String>(inputSet);

    }

    @Override

    public List<String> testSimpleListGet ( RequestContext ctx , List<String> inputList, TimeConstraints timeConstraints)

            throws SimpleException

    {

        ctx.setRequestLogExtension(new BaselineLogExtension(inputList.toArray(), null, null));

        return new ArrayList<String>(inputList);

    }

    @KPITimedEvent(value = "Baseline.service.testSimpleGet", catchFailures = true)

    @Override

    public SimpleResponse testSimpleGet(RequestContext ctx, String message, TimeConstraints timeConstraints) throws SimpleException {

        ctx.trace("Starting simple get for %s", message);

        ctx.setRequestLogExtension(new BaselineLogExtension(message, null, null));

        if (message.startsWith("FORWARD:")) {

            return baselineAsClient.testSimpleGet(ctx, "FORWARDED:"+ message.substring(8));

        } else {

            SimpleResponse response = new SimpleResponse();

            response.setMessage(message);

            return response;

        }

    }

 

  @KPITimedEvent(value = "Baseline.service.testSimpleGetQA", catchFailures = true)

  @Override

  public SimpleResponse testSimpleGetQA(RequestContext ctx, String message, TimeConstraints timeConstraints) throws SimpleException {

    ctx.setRequestLogExtension(new BaselineLogExtension(message, null, null));

    ctx.trace("Starting simple get for %s", message);

    if (message.equalsIgnoreCase("GET_CHANNEL_INFO")) {

      SimpleResponse response = new SimpleResponse();

      response.setMessage("ChannelId: " + ctx.getIdentity().toString());

      return response;

    }

    else if (message.equalsIgnoreCase("DELEGATE")) {

      SimpleResponseDelegate delegate = new SimpleResponseDelegateImpl();

      return new SimpleResponse(delegate);     

    }

    else {

      SimpleResponse response = new SimpleResponse();

      response.setMessage("service2-" + message);

      return response;

    }

  }

    @KPITimedEvent(value = "Baseline.service.testLargeGet", catchFailures = true)

    @Override

    public LargeRequest testLargeGet(RequestContext ctx, Integer size, TimeConstraints timeConstraints) throws SimpleException {

        ctx.trace("Starting large get for array of size %d", size);

        ctx.setRequestLogExtension(new BaselineLogExtension(size, null, null));

        LargeRequest result = new LargeRequest();

        result.setObjects(new ArrayList<ComplexObject>());

        result.setSize(size);

        result.setOddOrEven(size % 2 == 0 ? LargeRequestOddOrEvenEnum.EVEN : LargeRequestOddOrEvenEnum.ODD);

        for (int i = 0; i < size; i++) {

            ComplexObject o = new ComplexObject();

            o.setName("name " + i);

            o.setValue1(i);

            o.setValue2(i + 1);

            result.getObjects().add(o);

        }

        return result;

    }

    @KPITimedEvent(value = "Baseline.service.testSimpleTypeReplacement", catchFailures = true)

    @Override

    public SimpleContainer testSimpleTypeReplacement(RequestContext ctx, Integer simpleInt, Double simpleDouble, String simpleString,

                                                     SimpleValidValue simpleEnum, TimeConstraints timeConstraints) throws SimpleException {

        ctx.setRequestLogExtension(new BaselineLogExtension(simpleInt, simpleDouble, simpleEnum));

        SimpleContainer cont = new SimpleContainer();

        cont.setSimpleInt(simpleInt);

        cont.setSimpleDouble(simpleDouble);

        cont.setSimpleString(simpleString);

        cont.setSimpleEnum(simpleEnum);

        return cont;

    }

    @KPITimedEvent(value = "Baseline.service.testStringableLists", catchFailures = true)

    @Override

    public SimpleListContainer testStringableLists(RequestContext ctx, Set<Integer> intList, List<String> stringList,

                                                   List<SimpleValidValue> enumList, TimeConstraints timeConstraints) throws SimpleException {

        ctx.setRequestLogExtension(new BaselineLogExtension(intList.size(), stringList.size(), enumList.size()));

        SimpleListContainer cont = new SimpleListContainer();

        cont.setInts(new ArrayList<Integer>(intList));

        cont.setStrings(stringList);

        cont.setEnums(new HashSet<SimpleValidValue>(enumList));

        return cont;

    }

    @KPITimedEvent(value = "Baseline.service.testParameterStyles", catchFailures = true)

    @Override

    public List<String> testParameterStyles(RequestContext ctx,

                                            TestParameterStylesHeaderParamEnum headerParam, String secondHeaderParam, String queryParam, Date dateQueryParam, Float ok, TimeConstraints timeConstraints) {

        ctx.setRequestLogExtension(new BaselineLogExtension(queryParam, ok, null));

        List<String> response = new ArrayList<String>();

        response.add("secondHeaderParam=" + secondHeaderParam);

        response.add("queryParam=" + queryParam);

        response.add("headerParam=" + headerParam);

        response.add("dateQueryParam=" + dateQueryParam);

        response.add("ok=" + ok);

        return response;

    }

 

  @KPITimedEvent(value = "Baseline.service.testParameterStylesQA", catchFailures = true)

  @Override

  public SimpleResponse testParameterStylesQA(RequestContext ctx,

      TestParameterStylesQAHeaderParamEnum headerParam, String queryParam, Date dateQueryParam, TimeConstraints timeConstraints) {

    ctx.setRequestLogExtension(new BaselineLogExtension(queryParam, null, null));

    SimpleResponse response = new SimpleResponse();

    response.setMessage("headerParam=" + headerParam

                + ",queryParam=" + queryParam + ",dateQueryParam=" + dateQueryParam);

    return response;

  }

    @KPITimedEvent(value = "Baseline.service.testDateRetrieval", catchFailures = true)

    @Override

    public DateContainer testDateRetrieval(RequestContext ctx, DateContainer inputDates, TimeConstraints timeConstraints) throws SimpleException {

        ctx.setRequestLogExtension(new BaselineLogExtension(inputDates.getFirst(), inputDates.getLast(), inputDates.getDifference()));

        DateContainer response = new DateContainer();

        response.setFirst(inputDates.getFirst());

        response.setLast(inputDates.getLast());

        response.setName("First Passed Date: " + inputDates.getFirst() + ", Second Passed Date: " + inputDates.getLast());

        List<Date> dateList = inputDates.getAllDates();

        response.setAllDates(dateList);

        response.setDifference(inputDates.getDifference());

        return response;

    }

    @KPITimedEvent(value = "Baseline.service.testDoubleHandling", catchFailures = true)

    @Override

    public DoubleResponse testDoubleHandling(RequestContext ctx,

                                             DoubleContainer doubleContainer, Double doubleVal, TimeConstraints timeConstraints)

            throws SimpleException {

        ctx.setRequestLogExtension(new BaselineLogExtension(doubleContainer.getMap().size(), doubleContainer.getVal(), doubleVal));

        DoubleResponse resp = new DoubleResponse();

        resp.setMap(doubleContainer.getMap());

        resp.setTopLevelVal(doubleVal);

        resp.setVal(doubleContainer.getVal());

        return resp;

    }

    @KPITimedEvent(value = "Baseline.service.testComplexMutator", catchFailures = true)

    @Override

    public SimpleResponse testComplexMutator(RequestContext ctx, ComplexObject message, TimeConstraints timeConstraints) throws SimpleException {

        ctx.trace("Starting complex mutator for %s", message.getName());

        ctx.setRequestLogExtension(new BaselineLogExtension(message, "mutate", null));

        SimpleResponse response = new SimpleResponse();

        Integer val2 = message.getValue2();

        if (val2 == null) {

            val2 = 0;

        }

        response.setMessage(message.getName() + " = " + (message.getValue1() + val2));

        return response;

    }

    @KPITimedEvent(value = "Baseline.service.testLargePost", catchFailures = true)

    @Override

    public SimpleResponse testLargePost(RequestContext ctx, LargeRequest message, TimeConstraints timeConstraints) throws SimpleException {

        ctx.trace("Starting large post with array size %s", message.getSize());

        ctx.setRequestLogExtension(new BaselineLogExtension(message.getOddOrEven(), "largepost", message.getSize()));

        SimpleResponse response = new SimpleResponse();

        response.setMessage("There were " + message.getSize() + " items specified in the list, " + message.getObjects().size()

                + " actually");

        return response;

    }

 

  @KPITimedEvent(value = "Baseline.service.testLargePostQA", catchFailures = true)

  @Override

  public SimpleResponse testLargePostQA(RequestContext ctx, LargeRequest message, TimeConstraints timeConstraints)

      throws SimpleException {

    ctx.trace("Starting large post with array size %s", message.getSize());

    ctx.setRequestLogExtension(new BaselineLogExtension(message.getOddOrEven(), "largepostQA", message.getSize()));

    SimpleResponse response = new SimpleResponse();

   

    Boolean returnList = message.getReturnList();

    if ((returnList != null) && (returnList)) {

     

      List<ComplexObject> complexObjects = message.getObjects();

     

      StringBuffer namesBuff = new StringBuffer();

      namesBuff.append("Names: ");     

      StringBuffer value1sBuff = new StringBuffer();

      value1sBuff.append("Value1s: ");

      StringBuffer value2sBuff = new StringBuffer();

      value2sBuff.append("Value2s: ");

      for (ComplexObject complexObject: complexObjects) {

        if (complexObject == null) {

          namesBuff.append("null");         

          value1sBuff.append("null");

          value2sBuff.append("null");

        } else {

          namesBuff.append(complexObject.getName());         

          value1sBuff.append(complexObject.getValue1());

          value2sBuff.append( complexObject.getValue2());

        }

      }

      String names = namesBuff.toString();

      String value1s = value1sBuff.toString();

      String value2s = value2sBuff.toString();

     

      response.setMessage(names + " - " + value1s + " - " + value2s);

    } else {

      response.setMessage("There were " + message.getSize()

          + " items specified in the list, "

          + message.getObjects().size() + " actually");

    }

    return response;

  }

    @KPITimedEvent(value = "Baseline.service.testException", catchFailures = true)

    @Override

    public SimpleResponse testException(RequestContext ctx, String responseCode, String message, TimeConstraints timeConstraints) throws SimpleException, WotsitException {

        ctx.trace("Starting exception thrower with message %s", message);

        ResponseCode response;

        try {

            response = ResponseCode.valueOf(responseCode);

        }

        catch (IllegalArgumentException e) {

            response = ResponseCode.InternalError;

        }

        if (message.equals("throwRuntime")) {

            throw new RuntimeException("Requested");

        } else {

            try {

                SimpleExceptionErrorCodeEnum errCode = SimpleExceptionErrorCodeEnum.valueOf(message.toUpperCase(Locale.ENGLISH));

                throw new SimpleException(response, errCode, message);

            }

            catch (IllegalArgumentException e) {

                try {

                    WotsitExceptionErrorCodeEnum errCode = WotsitExceptionErrorCodeEnum.valueOf(message.toUpperCase(Locale.ENGLISH));

                    throw new WotsitException(e,

                            response,

                            errCode, (message.hashCode() % 2) != 0 ? WotsitExceptionTypeEnum.CHEESY : WotsitExceptionTypeEnum.SPICY,

                            String.valueOf(responseCode));

                }

                catch (IllegalArgumentException ex) {

                }

                throw new SimpleException(e,response, SimpleExceptionErrorCodeEnum.NULL, message);

            }

        }

    }

 

   @KPITimedEvent(value = "Baseline.service.testExceptionQA", catchFailures = true)

  @Override

  public SimpleResponse testExceptionQA(RequestContext ctx, String message, TimeConstraints timeConstraints)

      throws SimpleException, WotsitException {

    ctx.trace("Starting exception thrower with message %s", message);

    ctx.setRequestLogExtension(new BaselineLogExtension(null, null, null));

   

    try {

      SimpleExceptionErrorCodeEnum errCode = SimpleExceptionErrorCodeEnum

          .valueOf(message);

      throw new SimpleException(ResponseCode.Unauthorised, errCode,

          message);

    } catch (IllegalArgumentException e) {

      try {

        WotsitExceptionErrorCodeEnum errCode = WotsitExceptionErrorCodeEnum

            .valueOf(message);

        throw new WotsitException(e,

            ResponseCode.Forbidden,

            errCode,

            (message.hashCode() % 2 != 0) ? WotsitExceptionTypeEnum.CHEESY

                : WotsitExceptionTypeEnum.SPICY, message);

      } catch (IllegalArgumentException ex) {

      }

      throw new SimpleException(e,ResponseCode.Unauthorised,

          SimpleExceptionErrorCodeEnum.NULL, message);

    }

  }

    @KPITimedEvent(value = "Baseline.service.testNamedCougarException", catchFailures = true)

    @Override

    public SimpleResponse testNamedCougarException(RequestContext ctx, String errorCodeName, TimeConstraints timeConstraints) {

        throw new CougarServiceException(ServerFaultCode.valueOf(errorCodeName), "Test throwing an exception with error code: "+errorCodeName);

    }

    @KPITimedEvent(value = "Baseline.service.testSleep", catchFailures = true)

    @Override

    public void testSleep(RequestContext ctx, Long sleep, TimeConstraints timeConstraints) throws SimpleException {

        ctx.setRequestLogExtension(new BaselineLogExtension(sleep, null, null));

        if (sleep <= 0) {

            throw new SimpleException(ResponseCode.BadRequest, SimpleExceptionErrorCodeEnum.GENERIC, "Sleep must be > 0");

        }

        CountDownLatch latch = new CountDownLatch(1);

        outstandingSleeps.add(latch);

        try {

            latch.await(sleep, TimeUnit.MILLISECONDS);

    } catch (InterruptedException e) {

    }

        outstandingSleeps.remove(latch);

    }

    @KPITimedEvent(value = "Baseline.service.testSleep", catchFailures = true)

    @Override

    public Integer cancelSleeps(RequestContext ctx, TimeConstraints timeConstraints) throws SimpleException {

        ctx.setRequestLogExtension(new BaselineLogExtension(null, null, null));

        List<CountDownLatch> allSleeps = new ArrayList<CountDownLatch>(outstandingSleeps);

        outstandingSleeps.removeAll(allSleeps);

        for (CountDownLatch latch : allSleeps) {

            latch.countDown();

        }

        return allSleeps.size();

    }

    @KPITimedEvent(value = "Baseline.service.testSecureService", catchFailures = true)

    public SimpleResponse testSecureService(RequestContext ctx, String message, TimeConstraints timeConstraints) throws SimpleException {

         throw new UnsupportedOperationException("implement me");

    }

    @Override

    public IdentChain testIdentityChain(RequestContext ctx, TimeConstraints timeConstraints) throws SimpleException {

        ctx.setRequestLogExtension(new BaselineLogExtension(null, null, null));

        if (ctx.getIdentity() == null) {

            return null;

        }

        IdentChain result = new IdentChain();

        result.setIdentities(new ArrayList<Ident>());

        for (Identity i: ctx.getIdentity().getIdentities()) {

            Ident ident = new Ident();

            ident.setPrincipal(i.getPrincipal().getName());

            ident.setCredentialName(i.getCredential().getName());

            ident.setCredentialValue((String)i.getCredential().getValue());

            result.getIdentities().add(ident);

        }

        return result;

    }

    @KPITimedEvent(value = "Baseline.service.testNoParams", catchFailures = true)

    @Override

    public NoParamsResponse testNoParams(RequestContext ctx, TimeConstraints timeConstraints) throws SimpleException {

        ctx.setRequestLogExtension(new BaselineLogExtension(null, null, null));

        NoParamsResponse response = new NoParamsResponse();

        response.setStatus("hello");

        response.setVersion("1.0.0");

        return response;

    }

    @KPITimedEvent(value = "Baseline.service.testLargeMapGet", catchFailures = true)

    @Override

    public MapDataType testLargeMapGet(RequestContext ctx, Integer size, TimeConstraints timeConstraints) throws SimpleException {

        ctx.setRequestLogExtension(new BaselineLogExtension(size, null, null));

        MapDataType result = new MapDataType();

        result.setCache(new HashMap<Integer, ComplexObject>());

        result.setSomeMap(new HashMap<String, ComplexObject>());

        for (int i = 0; i < size; i++) {

            ComplexObject o = new ComplexObject();

            o.setName("name " + i);

            o.setValue1(i);

            o.setValue2(i + 1);

            result.getCache().put(i, o);

            result.getSomeMap().put(String.valueOf(i), o);

        }

        return result;

    }

    @KPITimedEvent(value = "Baseline.service.testMapsNameClash", catchFailures = true)

    @Override

    public SimpleResponseMap testMapsNameClash(RequestContext ctx, SimpleMap mapParam, TimeConstraints timeConstraints) throws SimpleException {

        ctx.setRequestLogExtension(new BaselineLogExtension(mapParam.getCache().size(), null, null));

        Set<Entry<String, String>> entry = mapParam.getCache().entrySet();

        SimpleResponseMap map = new SimpleResponseMap();

        map.setCache(new HashMap<String, String>());

        for (Entry<String, String> ent : entry) {

            map.getCache().put("RESULT:" + ent.getKey(), "RESULT:" + ent.getValue());

        }

        return map;

    }

    @KPITimedEvent(value = "Baseline.service.testListRetrieval", catchFailures = true)

    @Override

    public PrimitiveLists testListRetrieval(RequestContext ctx, Integer seed, TimeConstraints timeConstraints) throws SimpleException {

        ctx.setRequestLogExtension(new BaselineLogExtension(seed, null, null));

        PrimitiveLists response = new PrimitiveLists();

        Random rnd = new Random(seed);

        response.setBytes(new byte[rnd.nextInt(7) + 3]);

        for (int i = 0; i < response.getBytes().length; i++) {

            response.getBytes()[i] = (byte)rnd.nextInt();

        }

        response.setI32s(new ArrayList<Integer>());

        for (int i = 0; i < rnd.nextInt(7) + 3; i++) {

            response.getI32s().add(rnd.nextInt());

        }

        response.setI64s(new ArrayList<Long>());

        for (int i = 0; i < rnd.nextInt(7) + 3; i++) {

            response.getI64s().add(rnd.nextLong());

        }

        response.setFloats(new ArrayList<Float>());

        for (int i = 0; i < rnd.nextInt(7) + 3; i++) {

            response.getFloats().add(rnd.nextFloat());

        }

        response.setDoubles(new ArrayList<Double>());

        for (int i = 0; i < rnd.nextInt(7) + 3; i++) {

            response.getDoubles().add(rnd.nextDouble());

        }

        response.setStrings(new ArrayList<String>());

        for (int i = 0; i < rnd.nextInt(7) + 3; i++) {

            response.getStrings().add(String.valueOf((rnd.nextLong())));

        }

        response.setDates(new ArrayList<Date>());

        for (int i = 0; i < rnd.nextInt(7) + 3; i++) {

            response.getDates().add(new Date(rnd.nextLong()));

        }

        return response;

    }

    @Override

    public SimpleResponse testBodyParams(RequestContext ctx, String message, Integer value, ComplexObject complex, SimpleValidValue myEnum,

                                         ComplexObject anotherComplex, TimeConstraints timeConstraints) throws SimpleException {

        ctx.setRequestLogExtension(new BaselineLogExtension(message, value, complex));

        SimpleResponse response = new SimpleResponse();

        response.setMessage("message={" + message + "},value={" + value + "},complex={" + complex + "},myEnum={" + myEnum

                + "},anotherComplex={" + anotherComplex + "}");

        return response;

    }

    @Override

    public List<SimpleResponse> testDirectListReturn(RequestContext ctx, Integer seed, AsyncBehaviour async, TimeConstraints timeConstraints) throws SimpleException {

        ctx.setRequestLogExtension(new BaselineLogExtension(seed, "List", async));

        List<SimpleResponse> response = new ArrayList<SimpleResponse>();

        Random rnd = new Random(seed);

        for (int i = 0; i < rnd.nextInt(7) + 3; i++) {

            SimpleResponse sr = new SimpleResponse();

            sr.setMessage(String.valueOf(async));

            response.add(sr);

        }

        if (async == AsyncBehaviour.SYNC) {

            return response;

        } else {

      throw new SimpleException(ResponseCode.ServiceUnavailable,SimpleExceptionErrorCodeEnum.FORBIDDEN ,"Suspend, is no longer supported");

        }

    }

    @Override

    public Map<String, SimpleResponse> testDirectMapReturn(RequestContext ctx, Integer seed, AsyncBehaviour async, TimeConstraints timeConstraints) throws SimpleException {

        ctx.setRequestLogExtension(new BaselineLogExtension(seed, "Map", async));

        Map<String, SimpleResponse> response = new HashMap<String, SimpleResponse>();

        Random rnd = new Random(seed);

        for (int i = 0; i < rnd.nextInt(7) + 3; i++) {

            SimpleResponse sr = new SimpleResponse();

            sr.setMessage(String.valueOf(async));

            response.put(String.valueOf(i), sr);

        }

        if (async == AsyncBehaviour.SYNC) {

            return response;

        } else {

          throw new SimpleException(ResponseCode.ServiceUnavailable,SimpleExceptionErrorCodeEnum.FORBIDDEN ,"Suspend, is no longer supported");

        }

    }

 

    @KPITimedEvent(value = "Baseline.service.kpiTesting", catchFailures = true)

  @Override

  public SimpleResponse kpiTesting(RequestContext ctx, String message, TimeConstraints timeConstraints)

      throws SimpleException {

    ctx.setRequestLogExtension(new BaselineLogExtension(message, null, null));