/*
    * Copyright (C) 2013 4th Line GmbH, Switzerland
    *
    * The contents of this file are subject to the terms of either the GNU
    * Lesser General Public License Version 2 or later ("LGPL") or the
    * Common Development and Distribution License Version 1 or later
    * ("CDDL") (collectively, the "License"). You may not use this file
    * except in compliance with the License. See LICENSE.txt for more
    * information.
   *
   * 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.
   */
  
  package org.fourthline.cling.test.data;
  
  import org.fourthline.cling.model.meta.LocalDevice;
  import org.fourthline.cling.model.message.OutgoingDatagramMessage;
  import org.fourthline.cling.model.message.UpnpMessage;
  import org.fourthline.cling.model.message.UpnpOperation;
  import org.fourthline.cling.model.message.header.DeviceTypeHeader;
  import org.fourthline.cling.model.message.header.DeviceUSNHeader;
  import org.fourthline.cling.model.message.header.RootDeviceHeader;
  import org.fourthline.cling.model.message.header.ServiceTypeHeader;
  import org.fourthline.cling.model.message.header.ServiceUSNHeader;
  import org.fourthline.cling.model.message.header.UDNHeader;
  import org.fourthline.cling.model.message.header.USNRootDeviceHeader;
  import org.fourthline.cling.model.message.header.UpnpHeader;
  
  import java.util.List;
  
  import static org.testng.Assert.assertEquals;
  import static org.testng.Assert.assertTrue;
  
  /**
   * @author Christian Bauer
   */
  public class SampleUSNHeaders {
  
      public static void assertUSNHeaders(List<OutgoingDatagramMessage> msgs, LocalDevice rootDevice, LocalDevice embeddedDevice, UpnpHeader.Type ntstHeaderType) {
  
          // See the tables in UDA 1.0 section 1.1.2
  
          boolean gotRootDeviceFirstMsg = false;
          boolean gotRootDeviceSecondMsg = false;
          boolean gotRootDeviceThirdMsg = false;
  
          boolean gotEmbeddedDeviceFirstMsg = false;
          boolean gotEmbeddedDeviceSecondMsg = false;
  
          boolean gotFirstServiceMsg = false;
          boolean gotSecondServiceMsg = false;
  
          for (UpnpMessage<UpnpOperation> msg : msgs) {
  
              if (msg.getHeaders().getFirstHeader(ntstHeaderType, RootDeviceHeader.class) != null) {
                  assertEquals(
                          msg.getHeaders().getFirstHeader(UpnpHeader.Type.USN, USNRootDeviceHeader.class).getString(),
                          new USNRootDeviceHeader(rootDevice.getIdentity().getUdn()).getString()
                  );
                  gotRootDeviceFirstMsg = true;
              }
  
              UDNHeader foundUDN = msg.getHeaders().getFirstHeader(ntstHeaderType, UDNHeader.class);
              if (foundUDN != null && foundUDN.getString().equals(new UDNHeader(rootDevice.getIdentity().getUdn()).getString())) {
                  assertEquals(
                          msg.getHeaders().getFirstHeader(ntstHeaderType).getString(),
                          msg.getHeaders().getFirstHeader(UpnpHeader.Type.USN).getString()
                  );
                  gotRootDeviceSecondMsg = true;
              }
  
              if (foundUDN != null && foundUDN.getString().equals(new UDNHeader(embeddedDevice.getIdentity().getUdn()).getString())) {
                  assertEquals(
                          msg.getHeaders().getFirstHeader(ntstHeaderType).getString(),
                          msg.getHeaders().getFirstHeader(UpnpHeader.Type.USN).getString()
                  );
                  gotEmbeddedDeviceFirstMsg = true;
  
              }
  
              DeviceTypeHeader foundDeviceNTST = msg.getHeaders().getFirstHeader(ntstHeaderType, DeviceTypeHeader.class);
              if (foundDeviceNTST != null && foundDeviceNTST.getString().equals(new DeviceTypeHeader(rootDevice.getType()).getString())) {
                  assertEquals(
                          msg.getHeaders().getFirstHeader(UpnpHeader.Type.USN, DeviceUSNHeader.class).getString(),
                          new DeviceUSNHeader(rootDevice.getIdentity().getUdn(), rootDevice.getType()).getString()
                  );
                  gotRootDeviceThirdMsg = true;
              }
  
              if (foundDeviceNTST != null && foundDeviceNTST.getString().equals(new DeviceTypeHeader(embeddedDevice.getType()).getString())) {
                  assertEquals(
                          msg.getHeaders().getFirstHeader(UpnpHeader.Type.USN, DeviceUSNHeader.class).getString(),
                          new DeviceUSNHeader(embeddedDevice.getIdentity().getUdn(), embeddedDevice.getType()).getString()
                  );
                  gotEmbeddedDeviceSecondMsg = true;
              }
  
             ServiceTypeHeader foundServiceNTST = msg.getHeaders().getFirstHeader(ntstHeaderType, ServiceTypeHeader.class);
             if (foundServiceNTST != null && foundServiceNTST.getString().equals(new ServiceTypeHeader(SampleServiceOne.getThisServiceType()).getString())) {
                 assertEquals(
                         msg.getHeaders().getFirstHeader(UpnpHeader.Type.USN, ServiceUSNHeader.class).getString(),
                         new ServiceUSNHeader(rootDevice.getIdentity().getUdn(), SampleServiceOne.getThisServiceType()).getString()
                 );
                 gotFirstServiceMsg = true;
             }
 
             if (foundServiceNTST != null && foundServiceNTST.getString().equals(new ServiceTypeHeader(SampleServiceTwo.getThisServiceType()).getString())) {
                 assertEquals(
                         msg.getHeaders().getFirstHeader(UpnpHeader.Type.USN, ServiceUSNHeader.class).getString(),
                         new ServiceUSNHeader(rootDevice.getIdentity().getUdn(), SampleServiceTwo.getThisServiceType()).getString()
                 );
                 gotSecondServiceMsg = true;
             }
         }
 
         assertTrue(gotRootDeviceFirstMsg);
         assertTrue(gotRootDeviceSecondMsg);
         assertTrue(gotRootDeviceThirdMsg);
 
         assertTrue(gotEmbeddedDeviceFirstMsg);
         assertTrue(gotEmbeddedDeviceSecondMsg);
 
         assertTrue(gotFirstServiceMsg);
         assertTrue(gotSecondServiceMsg);
 
     }
 }