////////////////////////////////////////////////////
// Locks onto a specific client port (for session tracking)
void EQPacket::lockOnClient(in_port_t serverPort, in_port_t clientPort)
{
  m_serverPort = serverPort;
  m_clientPort = clientPort;

  if (!m_playbackPackets)
  {
    if (m_mac.length() == 17)
    {
      m_packetCapture->setFilter(m_device, 
				 m_mac,
				 m_realtime, 
				 MAC_ADDRESS_TYPE, 0, 
				 m_clientPort);
      emit filterChanged();
      seqInfo("EQPacket: SEQStart detected, pcap filter: EQ Client %s, Client port %d",
	      (const char*)m_mac, 
	      m_clientPort);
    }
    else
    {
      m_packetCapture->setFilter(m_device, 
				 m_ip,
				 m_realtime, 
				 IP_ADDRESS_TYPE, 0, 
				 m_clientPort);
      emit filterChanged();
      seqInfo("EQPacket: SEQStart detected, pcap filter: EQ Client %s, Client port %d",
	      (const char*)m_ip, 
	      m_clientPort);
    }
  }
  
  emit clientPortLatched(m_clientPort);
}

void SpellShell::spellMessage(QString &str)
{
   QString spell = str.right(str.length() - 7); // drop 'Spell: '
   bool b = false;
   // Your xxx has worn off.
   // Your target resisted the xxx spell.
   // Your spell fizzles.
   seqInfo("*** spellMessage *** %s", spell.latin1());
   if (spell.left(25) == QString("Your target resisted the ")) {
      spell = spell.right(spell.length() - 25);
      spell = spell.left(spell.length() - 7);
      seqInfo("RESIST: '%s'", spell.latin1());
      b = true;
   } else if (spell.right(20) == QString(" spell has worn off.")) {
      spell = spell.right(spell.length() - 5);
      spell = spell.left(spell.length() - 20);
      seqInfo("WORE OFF: '%s'", spell.latin1());
      b = true;
   }

   if (b) {
      // Can't really tell which spell/target, so just delete the last one
      for(QValueList<SpellItem*>::Iterator it = m_spellList.begin();
         it != m_spellList.end(); it++) {
         if ((*it)->spellName() == spell) {
            (*it)->setDuration(0);
            break;
         }
      }
   }
}

///////////////////////////////////////////
// Monitor for packets on the specified device
void EQPacket::monitorDevice(const QString& dev)
{
  // set the device to use
  m_device = dev;

  // make sure we aren't playing back packets
  if (m_playbackPackets != PLAYBACK_OFF)
    return;

  // stop the current packet capture
  m_packetCapture->stop();

  // setup for capture on new device
  if (!m_ip.isEmpty())
  {
    struct hostent *he;
    struct in_addr  ia;

    /* Substitute "special" IP which is interpreted 
       to set up a different filter for picking up new sessions */
    
    if (m_ip == "auto")
      inet_aton (AUTOMATIC_CLIENT_IP, &ia);
    else if (inet_aton (m_ip, &ia) == 0)
    {
      he = gethostbyname(m_ip);
      if (!he)
	seqFatal("Invalid address; %s", (const char*)m_ip);

      memcpy (&ia, he->h_addr_list[0], he->h_length);
    }
    m_client_addr = ia.s_addr;
    m_ip = inet_ntoa(ia);
    
    if (m_ip ==  AUTOMATIC_CLIENT_IP)
    {
      m_detectingClient = true;
      seqInfo("Listening for first client seen.");
    }
    else
    {
      m_detectingClient = false;
      seqInfo("Listening for client: %s",
	     (const char*)m_ip);
    }
  }
 
  resetEQPacket();

  // restart packet capture
  if (m_mac.length() == 17)
    m_packetCapture->start(m_device, 
			   m_mac, 
			   m_realtime, MAC_ADDRESS_TYPE );
  else
    m_packetCapture->start(m_device, m_ip, 
			   m_realtime, IP_ADDRESS_TYPE );
  emit filterChanged();
}

void EQPacketTypeDB::list(void) const
{
  seqInfo("EQPacketTypeDB contains %d types (in %d buckets)",
	  m_typeSizeDict.count(), m_typeSizeDict.size());

  QAsciiDictIterator<size_t> it(m_typeSizeDict);

  while (it.current())
  {
    seqInfo("\t%s = %d", it.currentKey(), *(it.current()));
    ++it;
  }
}

std::vector<READ> vecStrToReadObjs(const VecStr & strs, const std::string & stubName){
	std::vector<READ> ans;
	for(const auto & strPos : iter::range(strs.size())){
		ans.emplace_back(READ(seqInfo(stubName + "." + leftPadNumStr(strPos, strs.size()), strs[strPos])));
	}
	return ans;
}

void SpellShell::timeout()
{
  SpellItem* spell;

  QValueList<SpellItem*>::Iterator it = m_spellList.begin();
  while (it != m_spellList.end()) 
  {
    spell = *it;

    int d = spell->duration() -
      pSEQPrefs->getPrefInt("SpellTimer", "SpellList", 6);
    if (d > -6) 
    {
      spell->setDuration(d);
      emit changeSpell(spell);
      it++;
    } 
    else 
    {
      seqInfo("SpellItem '%s' finished.", (*it)->spellName().latin1());
      if (m_lastPlayerSpell == spell)
	m_lastPlayerSpell = 0;
      emit delSpell(spell);
      it = m_spellList.remove(it);
      delete spell;
    }
   }

  if (m_spellList.count() == 0)
    m_timer->stop();
}

////////////////////////////////////////////////////
// Handle zone2client stream closing
void EQPacket::closeStream(uint32_t sessionId, EQStreamID streamId)
{
  // If this is the zone server session closing, reset the pcap filter to
  // a non-exclusive form
  if ((streamId == zone2client || streamId == client2zone) &&
         (m_playbackPackets == PLAYBACK_OFF || 
          m_playbackPackets == PLAYBACK_FORMAT_TCPDUMP))
  {
    m_packetCapture->setFilter(m_device, m_ip,
			       m_realtime, IP_ADDRESS_TYPE, 0, 0);
    emit filterChanged();
  }

  // Pass the close onto the streams
  m_client2WorldStream->close(sessionId, streamId, m_session_tracking);
  m_world2ClientStream->close(sessionId, streamId, m_session_tracking);
  m_client2ZoneStream->close(sessionId, streamId, m_session_tracking);
  m_zone2ClientStream->close(sessionId, streamId, m_session_tracking);

  // If we just closed the zone server session, unlatch the client port
  if (streamId == zone2client || streamId == client2zone)
  {
    m_clientPort = 0;
    m_serverPort = 0;

    emit clientPortLatched(m_clientPort);

    seqInfo("EQPacket: SessionDisconnect detected, awaiting next zone session,  pcap filter: EQ Client %s",
	  (const char*)m_ip);
  }
}

void SpawnListWindow3::doubleClicked(const QModelIndex& index)
{
	const Item* item = m_spawnModel->item(index);
	if (item != NULL)
	{
		seqInfo("%s", (const char*)m_spawnModel->filterString(item));
	}
}

void Filters::list(void) const
{
  FilterMap::const_iterator it;

  seqInfo("Filters from file '%s':",
	 (const char*)m_file);
  // iterate over the filters
  for (it = m_filters.begin(); it != m_filters.end(); it++)
  {
    // print the header
    seqInfo("Filter Type '%s':", 
	   (const char*)m_types.name(it->first));

    // list off the actual filters
    it->second->listFilters();
  }
}

static std::vector<readObject> createCondensedObjects(std::vector<T> reads) {
  std::vector<readObject> ans;
  readVec::allSetCondensedSeq(reads);
  for (const auto& read : reads) {
    ans.emplace_back(readObject(seqInfo(read.seqBase_.name_, read.condensedSeq,
                                        read.condensedSeqQual)));
  }
  return ans;
}

void
Filter::listFilters(void)
{
  FilterItem *re;

#ifdef DEBUG_FILTER
//  seqDebug("Filter::listFilters");
#endif

  FilterListIterator it(m_filterItems);
  for (re = it.toFirst(); re != NULL; re = ++it)
  {
    if (re->minLevel() || re->maxLevel())
      seqInfo("\t'%s' (%d, %d)", 
	     (const char*)re->name().utf8(), re->minLevel(), re->maxLevel());
    else
      seqInfo("\t'%s'", (const char*)re->name().utf8());
  }
}

std::vector<baseReadObject> alignToSeq(const std::vector<READ>& reads,
                                       const REF& reference, aligner& alignObj,
                                       bool local, bool usingQuality) {
  std::vector<baseReadObject> output;
  output.emplace_back(baseReadObject(reference));
  for (const auto& read : reads) {
    alignObj.alignCache(reference, read, local);
    output.emplace_back(baseReadObject(seqInfo(
        read.seqBase_.name_ + "_score:" + std::to_string(alignObj.parts_.score_),
        alignObj.alignObjectB_.seqBase_.seq_,
        alignObj.alignObjectB_.seqBase_.qual_)));
  }
  return output;
}

void ExperienceWindow::calculateZEM(long xp_gained, int mob_level) 
{
   float gbonus=1.00;
   int penalty; 
   int myLevel = m_player->level();
   int group_ag;
   gbonus = m_group->groupBonus();
   group_ag = m_group->totalLevels();
   if (m_group->groupSize())
   {
     seqInfo("MY Level: %d GroupTot: %d BONUS   :%d", 
	     myLevel, group_ag, gbonus * 100);
   }
   // WAR and ROG are at 10 since thier EXP is not scaled to compensate
   // for thier bonus
   switch (m_player->classVal())
   {
      case 1 : penalty = 10; break; // WAR
      case 2 : penalty = 10; break; // CLR
      case 3 : penalty = 14; break; // PAL
      case 4 : penalty = 14; break; // RNG
      case 5 : penalty = 14; break; // SHD
      case 6 : penalty = 10; break; // DRU
      case 7 : penalty = 12; break; // MNK
      case 8 : penalty = 14; break; // BRD
      case 9 : penalty = 10; break; // ROG
      case 10: penalty = 10; break; // SHM
      case 11: penalty = 11; break; // NEC
      case 12: penalty = 11; break; // MAG
      case 13: penalty = 11; break; // ENC
      default: /* why are we here? */
         penalty = 10; break; 
   }
   unsigned char ZEM = (unsigned char) ((float)xp_gained*((float)((float)group_ag/(float)myLevel)*(float)((float)1.0/(float)gbonus))*((float)1/(float)(mob_level*mob_level))*((float)10/(float)penalty));
   seqInfo("xpgained: %ld group_ag: %d myLevel: %d gbonus: %d mob_level: %d penalty: %d ", xp_gained, group_ag, myLevel, gbonus, mob_level, penalty);
   seqInfo("ZEM - ZEM - ZEM ===== %d ", ZEM);
}

///////////////////////////////////////////////////////////////
// Process a session disconnect if it is for us
void EQPacketStream::close(uint32_t sessionId, EQStreamID /*streamId*/,
  uint8_t sessionTracking)
{
  if (sessionId == m_sessionId)
  {
     // Close is for us
     reset();
     setSessionTracking(sessionTracking);

#ifdef PACKET_SESSION_DIAG
     seqInfo("EQPacket: SessionDisconnected received on stream %s (%d). Closing session %u on stream %s (%d).",
       EQStreamStr[streamId], streamId, sessionId,
       EQStreamStr[m_streamid], m_streamid);
#endif
  }
}

///////////////////////////////////////////
// Set the IP address of the client to monitor
void EQPacket::monitorIPClient(const QString& ip)
{
  m_ip = ip;
  struct in_addr  ia;
  inet_aton (m_ip, &ia);
  m_client_addr = ia.s_addr;
  emit clientChanged(m_client_addr);
  
  resetEQPacket();
  
  seqInfo("Listening for IP client: %s", (const char*)m_ip);
  if (!m_playbackPackets)
  {
    m_packetCapture->setFilter(m_device, m_ip,
			       m_realtime, 
			       IP_ADDRESS_TYPE, 0, 0);
    emit filterChanged();
  }
}

void CategoryMgr::reloadCategories(void)
{
  clearCategories();
  m_changed = false;
  
  QString section = "CategoryMgr";
  int i = 0;
  QString prefBaseName;
  QString tempStr;
  for(i = 1; i <= tMaxNumCategories; i++)
  {
    prefBaseName.sprintf("Category%d_", i);
    
    // attempt to pull a button title from the preferences
    tempStr = prefBaseName + "Name";
    if (pSEQPrefs->isPreference(tempStr, section))
    {
      QString name = pSEQPrefs->getPrefString(tempStr, section);
      QString filter =
	pSEQPrefs->getPrefString(prefBaseName + "Filter", section);
      QColor color = pSEQPrefs->getPrefColor(prefBaseName + "Color", 
					     section, QColor("black"));
      tempStr = prefBaseName + "FilterOut";
      QString filterout;
      if (pSEQPrefs->isPreference(tempStr, section))
	filterout = pSEQPrefs->getPrefString(tempStr, section);
	
      //seqDebug("%d: Got '%s' '%s' '%s'", i, name, filter, color);
      if (!name.isEmpty() && !filter.isEmpty())
      {
        Category* newcat = new Category(name, filter, filterout, color);
	
        m_categories.append(newcat);
      }
    }
  }
  
   // signal that the categories have been loaded
   emit loadedCategories();

   seqInfo("Categories Reloaded");
}

void GuildMgr::readGuildList()
{
	QFile guildsfile(guildsFileName);

	m_guildMap.clear();
	if (guildsfile.open(QIODevice::ReadOnly))
	{
		while (!guildsfile.atEnd())
		{
			char szGuildName[64] = {0};
			
			guildsfile.readBlock(szGuildName, sizeof(szGuildName));
			
			// seqDebug("GuildMgr::readGuildList - read guild '%s'", szGuildName);
			m_guildMap.push_back(QString::fromUtf8(szGuildName));
		}

		guildsfile.close();
		seqInfo("GuildMgr: Guildsfile loaded");
	}
	else
		seqWarn("GuildMgr: Could not load guildsfile, %s", (const char*)guildsFileName);
}

void SpawnMonitor::loadSpawnPoints()
{
  QString fileName;
  
  fileName = m_zoneName + ".sp";

  QFileInfo fileInfo = 
    m_dataLocMgr->findExistingFile("spawnpoints", fileName, false);

  if (!fileInfo.exists())
  {
    seqWarn("Can't find spawn point file %s", 
	   (const char*)fileInfo.absFilePath());
    return;
  }
  
  fileName = fileInfo.absFilePath();

  QFile spFile(fileName);
  
  if (!spFile.open(IO_ReadOnly))
  {
    seqWarn( "Can't open spawn point file %s", (const char*)fileName );
    return;
  }
  
  QTextStream input( &spFile );
  
  int16_t x, y, z;
  unsigned long diffTime;
  uint32_t count;
  QString name;

  while (!input.atEnd())
  {
    input >> x;
    input >> y;
    input >> z;
    input >> diffTime;
    input >> count;
    name = input.readLine();
    name = name.stripWhiteSpace();
    
    EQPoint	loc(x, y, z);
    SpawnPoint*	p = new SpawnPoint( 0, loc, name, diffTime, count );
    if (p)
    {
      QString key = p->key();
      
      if (!m_points.find(key))
      {
	m_points.insert(key, p);
	emit newSpawnPoint(p);
      }
      else
      {
	seqWarn("Warning: spawn point key already in use!");
	delete p;
      }
    }
  }

  seqInfo("Loaded spawn points: %s", (const char*)fileName);
  m_modified = false;
}