/*
 * Class:     mapnik_FeatureTypeStyle
 * Method:    collectAttributes
 * Signature: ()Ljava/util/Set;
 */
JNIEXPORT jobject JNICALL Java_mapnik_FeatureTypeStyle_collectAttributes
  (JNIEnv *env, jobject styleobject)
{
	mapnik::feature_type_style* style=LOAD_FEATURE_TYPE_STYLE_POINTER(styleobject);
	const std::vector<mapnik::rule>& rules(style->get_rules());

	std::set<std::string> attrs;
	mapnik::attribute_collector collector(attrs);
	BOOST_FOREACH(mapnik::rule const& r, rules) {
		collector(r);
	}

void factor_vm::collect_to_tenured() {
  /* Copy live objects from aging space to tenured space. */
  to_tenured_collector collector(this);

  mark_stack.clear();

  collector.trace_roots();
  collector.trace_contexts();

  gc_event* event = current_gc->event;

  if (event)
    event->started_card_scan();
  collector.trace_cards(data->tenured, card_points_to_aging, full_unmarker());
  if (event)
    event->ended_card_scan(collector.cards_scanned, collector.decks_scanned);

  if (event)
    event->started_code_scan();
  collector.trace_code_heap_roots(&code->points_to_aging);
  if (event)
    event->ended_code_scan(collector.code_blocks_scanned);

  collector.tenure_reachable_objects();

  data->reset_generation(&nursery);
  data->reset_generation(data->aging);
  code->clear_remembered_set();
}

void
makeAndDisplayCM( char* name, char* pool )
{
	Daemon collector( DT_COLLECTOR, name, pool );
	Daemon negotiator( DT_NEGOTIATOR, name, pool );
	Daemon view_collector( DT_VIEW_COLLECTOR, name, pool );

	if( ! collector.locate() ) {
		dprintf( dflag, "%s\n", collector.error() );
	} else { 
		collector.display( dflag );
	} 
	dprintf( dflag, "\n" );
	if( ! negotiator.locate() ) {
		dprintf( dflag, "%s\n", negotiator.error() );
	} else { 
		negotiator.display( dflag );
	} 
	dprintf( dflag, "\n" );
	if( ! view_collector.locate() ) {
		dprintf( dflag, "%s\n", view_collector.error() );
	} else { 
		view_collector.display( dflag );
	} 
	dprintf( dflag, "\n" );
}

void ElementRuleCollector::matchSlottedPseudoElementRules(MatchRequest& matchRequest, StyleResolver::RuleRange& ruleRange)
{
    auto* maybeSlotted = &m_element;
    for (auto* hostShadowRoot = m_element.parentNode()->shadowRoot(); hostShadowRoot; hostShadowRoot = maybeSlotted->parentNode()->shadowRoot()) {
        auto* slot = hostShadowRoot->findAssignedSlot(*maybeSlotted);
        if (!slot)
            return;

        matchRequest.treeContextOrdinal++;

        // In nested case the slot may itself be assigned to a slot. Collect ::slotted rules from all the nested trees.
        maybeSlotted = slot;
        if (!hostShadowRoot->styleScope().resolver().ruleSets().isAuthorStyleDefined())
            continue;
        // Find out if there are any ::slotted rules in the shadow tree matching the current slot.
        // FIXME: This is really part of the slot style and could be cached when resolving it.
        ElementRuleCollector collector(*slot, hostShadowRoot->styleScope().resolver().ruleSets().authorStyle(), nullptr);
        auto slottedPseudoElementRules = collector.collectSlottedPseudoElementRulesForSlot(matchRequest.includeEmptyRules);
        if (!slottedPseudoElementRules)
            continue;
        // Match in the current scope.
        SetForScope<bool> change(m_isMatchingSlottedPseudoElements, true);

        MatchRequest scopeMatchRequest(nullptr, matchRequest.includeEmptyRules, matchRequest.treeContextOrdinal);
        collectMatchingRulesForList(slottedPseudoElementRules.get(), scopeMatchRequest, ruleRange);

        m_keepAliveSlottedPseudoElementRules.append(WTFMove(slottedPseudoElementRules));
    }
}

hkvVec3 RPG_Projectile::SweepPhantom(hkvVec3 newPosition)
{
  hkVector4 hCurrentPosition, hNewPosition;
  RPG_VisionHavokConversion::VisionToHavokPoint(m_currentPosition, hCurrentPosition);
  RPG_VisionHavokConversion::VisionToHavokPoint(newPosition, hNewPosition);

  hkpLinearCastInput lci;
  {
    lci.m_startPointTolerance = 0.01f;
    lci.m_maxExtraPenetration = 0.01f;
    lci.m_to = hNewPosition;
  }
  RPG_ProjectilePointCollector collector(this);

  VASSERT(m_shapePhantom);
  if(m_shapePhantom)
  {
    // move shape phantom to the last frame's position, and sweep toward the current frame's position
    vHavokPhysicsModule::GetInstance()->MarkForWrite();
    m_shapePhantom->setPositionAndLinearCast(hCurrentPosition, lci, collector, HK_NULL);
    vHavokPhysicsModule::GetInstance()->UnmarkForWrite();
  }

  if(collector.m_hit)
  {
    return collector.m_hitPoint;
  }
  else
  {
    return newPosition;
  }
}

void DocumentStyleSheetCollection::updateActiveStyleSheets(StyleEngine* engine, StyleResolverUpdateMode updateMode)
{
    StyleSheetCollection collection;
    ActiveDocumentStyleSheetCollector collector(collection);
    collectStyleSheets(engine, collector);

    StyleSheetChange change;
    analyzeStyleSheetChange(updateMode, collection, change);

    if (change.styleResolverUpdateType == Reconstruct) {
        engine->clearMasterResolver();
        // FIMXE: The following depends on whether StyleRuleFontFace was modified or not.
        // No need to always-clear font cache.
        engine->clearFontCache();
    } else if (StyleResolver* styleResolver = engine->resolver()) {
        if (change.styleResolverUpdateType != Additive) {
            ASSERT(change.styleResolverUpdateType == Reset);
            styleResolver->resetAuthorStyle(treeScope());
            engine->removeFontFaceRules(change.fontFaceRulesToRemove);
            styleResolver->removePendingAuthorStyleSheets(m_activeAuthorStyleSheets);
            styleResolver->lazyAppendAuthorStyleSheets(0, collection.activeAuthorStyleSheets());
        } else {
            styleResolver->lazyAppendAuthorStyleSheets(m_activeAuthorStyleSheets.size(), collection.activeAuthorStyleSheets());
        }
    }
    if (change.requiresFullStyleRecalc)
        document().setNeedsStyleRecalc(SubtreeStyleChange);

    collection.swap(*this);

    updateUsesRemUnits();
}

void cAnnunciator::GetChildren( cObject::Children& children ) const
{
    cObject::GetChildren( children );

    ObjectCollector collector( children );
    std::for_each( m_as.begin(), m_as.end(), collector );
}

hkDemo::Result UserRayHitCollectorDemo::stepDemo()
{
	//
	// shoot two times four colored rays.
	//  1. each ray should only hit the object with the same color
	//  2. each ray should only hit the triangles (which are at the same x-coord as the object)
	//
	m_time += m_timestep;

	{
		//
		//	Setup the ray coordinates
		//
		hkpWorldRayCastInput ray;
		{
			ray.m_from.set(-4.f, 0.f, 0.0f );
			ray.m_to.set ( 25.f, 0.f, 2.5f * hkMath::cos(m_time * 0.5f));
		}

		//
		//	Do the raycaster
		//
		{
			UserRayHitCollector collector(ray);
			m_world->lock();
			m_world->castRay( ray, collector );
			m_world->unlock();
			collector.displayFinalRay();
		}
	}

	return hkDefaultPhysicsDemo::stepDemo();
}

void factor_vm::collect_nursery() {
  /* Copy live objects from the nursery (as determined by the root set and
     marked cards in aging and tenured) to aging space. */
  nursery_collector collector(this);

  collector.trace_roots();
  collector.trace_contexts();

  gc_event* event = current_gc->event;

  if (event)
    event->started_card_scan();
  collector.trace_cards(data->tenured, card_points_to_nursery,
                        simple_unmarker(card_points_to_nursery));
  if (data->aging->here != data->aging->start) {
    collector.trace_cards(data->aging, card_points_to_nursery, full_unmarker());
  }
  if (event)
    event->ended_card_scan(collector.cards_scanned, collector.decks_scanned);

  if (event)
    event->started_code_scan();
  collector.trace_code_heap_roots(&code->points_to_nursery);
  if (event)
    event->ended_code_scan(collector.code_blocks_scanned);

  collector.cheneys_algorithm();

  data->reset_generation(&nursery);
  code->points_to_nursery.clear();
}

void QUCoverGroup::showCovers() {
	list->model()->clear();
	list->hide();

	foreach(QFileInfo fi, collector()->results())
		list->model()->addCover(fi.filePath());

	list->selectionModel()->setCurrentIndex(list->model()->index(0), QItemSelectionModel::Select);

	if(list->model()->rowCount() > 0) {
		// TODO: fix this mess! - I just want to see all content all the time ... T_T
		list->show();

		int itemCount = list->model()->rowCount();

		int maxItemHeight = 1;
		for(int i = 0; i < itemCount; i++)
			maxItemHeight = qMax(maxItemHeight, list->sizeHintForRow(i));

		int rowCount = qRound((double)itemCount / 5.0);

		if(rowCount * 5 < itemCount)
			rowCount++;

		list->setMinimumHeight(maxItemHeight * qMax(1, rowCount));
	}
}

int main(int argc, char* argv[])
{
  try
  {
    terrama2::core::TerraMA2Init terramaRaii("example", 0);
    terrama2::core::registerFactories();

    {
      QCoreApplication app(argc, argv);
      auto& serviceManager = terrama2::core::ServiceManager::getInstance();
      te::core::URI uri("pgsql://"+TERRAMA2_DATABASE_USERNAME+":"+TERRAMA2_DATABASE_PASSWORD+"@"+TERRAMA2_DATABASE_HOST+":"+TERRAMA2_DATABASE_PORT+"/"+TERRAMA2_DATABASE_DBNAME);
      serviceManager.setLogConnectionInfo(uri);
      serviceManager.setInstanceId(1);

      auto dataManager = std::make_shared<terrama2::services::collector::core::DataManager>();

      addInput(dataManager);
      addOutput(dataManager);

      terrama2::services::collector::core::Service service(dataManager);
      auto logger = std::make_shared<terrama2::services::collector::core::CollectorLogger>();
      logger->setConnectionInfo(uri);
      service.setLogger(logger);
      service.start();

      terrama2::services::collector::core::Collector* collector(new terrama2::services::collector::core::Collector());
      terrama2::services::collector::core::CollectorPtr collectorPtr(collector);
      collector->id = 777;
      collector->projectId = 1;
      collector->serviceInstanceId = 1;
      collector->filter.region = terrama2::core::ewktToGeom("SRID=4326;POLYGON((-73.8036991603083 -9.81412714740936,-73.8036991603083 2.24662115728613,-56.097053202293 2.24662115728613,-56.097053202293 -9.81412714740936,-73.8036991603083 -9.81412714740936))");
      collector->filter.cropRaster = true;
      collector->filter.discardBefore = terrama2::core::TimeUtils::stringToTimestamp("2016-11-25T06:00:00.000-02:00", terrama2::core::TimeUtils::webgui_timefacet);
      collector->filter.discardAfter = terrama2::core::TimeUtils::stringToTimestamp("2016-11-25T12:00:00.000-02:00", terrama2::core::TimeUtils::webgui_timefacet);

      collector->inputDataSeries = 1;
      collector->outputDataSeries = 2;
      collector->inputOutputMap.emplace(1, 2);

      dataManager->add(collectorPtr);

      service.addToQueue(collectorPtr->id, terrama2::core::TimeUtils::nowUTC());

      QTimer timer;
      QObject::connect(&timer, SIGNAL(timeout()), QCoreApplication::instance(), SLOT(quit()));
      timer.start(10000);
      app.exec();

      service.stopService();
    }
  }
  catch(...)
  {
    std::cout << "\n\nException...\n" << std::endl;
  }

  return 0;
}

bool    plAgeLoader::IUnloadAge()
{
    plNetClientApp* nc = plNetClientApp::GetInstance();
    nc->DebugMsg( "Net: Unloading age {}", fAgeName);

    hsAssert( (fFlags & kLoadMask)==0, "already loading or unloading an age?"); 
    fFlags |= kUnLoadingAge;
    
    plAgeBeginLoadingMsg* msg = new plAgeBeginLoadingMsg();
    msg->fLoading = false;
    msg->Send();

    // Note: instead of going from the .age file, we just want a list of what
    // is REALLY paged in for this age. So ask the resMgr!
    plUnloadAgeCollector collector(fAgeName);
    // WARNING: unsafe cast here, but it's ok, until somebody is mean and makes a non-plResManager resMgr
    ( (plResManager *)hsgResMgr::ResMgr() )->IterateAllPages( &collector );

    // Dat was easy...
    plKey clientKey = hsgResMgr::ResMgr()->FindKey( kClient_KEY );

    // Build up a list of all the rooms we're going to page out
    plKeyVec newPageOuts;

    int i;
    for( i = 0; i < collector.fPages.GetCount(); i++ )
    {
        plRegistryPageNode *page = collector.fPages[ i ];

        plKey roomKey = plKeyFinder::Instance().FindSceneNodeKey( page->GetPageInfo().GetLocation() );
        if( roomKey != nil && roomKey->ObjectIsLoaded() )
        {
            nc->DebugMsg( "\tPaging out room {}\n", page->GetPageInfo().GetPage() );
            newPageOuts.push_back(roomKey);
        }
    }

    // Put them in our pending page outs
    for( i = 0; i < newPageOuts.size(); i++ )
        fPendingPageOuts.push_back(newPageOuts[i]);

    // ...then send the unload messages.  That way we ensure the list is complete
    // before any messages get processed
    for( i = 0; i < newPageOuts.size(); i++ )
    {
        plClientMsg *pMsg1 = new plClientMsg( plClientMsg::kUnloadRoom );
        pMsg1->AddRoomLoc(newPageOuts[i]->GetUoid().GetLocation());
        pMsg1->Send( clientKey );
    }
    
    if ( newPageOuts.size()==0 )
    {
        // age is done unloading because it has no pages?
        NotifyAgeLoaded( false );
    }

    return true;
}

/**
 * Find all files with a specific name.
 */
size_t File::find(FileList &result, const std::string &fileNameRegex, bool dirs, bool special) const
{
    FileFilterAnd filter(new FileTypeFilter(dirs, true, special), new FileRegexFilter(fileNameRegex));
    FileCollector collector(&result, filter);

    // visit all with maxDepth 100, follow symlinks
    visit(collector, 100, true, special);
    return collector.size();
}

int main(int argc, char *argv[]) {

	int lport = DEFAULT_LISTEN_PORT;
	std::string proto = "udp";

	msg_setlevel(MSG_DEBUG);
	
	signal(SIGINT, sigint);

	if (!(argc == 1 || argc == 2 || argc == 3)) {
		usage();
		return -1;
	}
	
	if (argc == 2)
		proto = argv[1];
	if (argc == 3)
		lport = atoi(argv[2]);

	IpfixReceiver* ipfixReceiver = 0;
	if (proto == "udp") {
		msg(MSG_INFO, "Creating UDP listener on port %i", lport);
		ipfixReceiver = new IpfixReceiverUdpIpV4(lport);
	} else if (proto == "sctp") {
#ifdef SUPPORT_SCTP
		ipfixReceiver = new IpfixReceiverSctpIpV4(lport, "127.0.0.1");
#else
		msg(MSG_FATAL, "testcollector has been compiled without sctp support");
		return -1;
#endif
	} else {
		msg(MSG_FATAL, "Protocol %s is not supported as a transport protocol for IPFIX data", proto.c_str()); 
		return -1;
	}

	IpfixCollector collector(ipfixReceiver);
	ConnectionQueue<IpfixRecord*> queue(100);
	IpfixPrinter printer;

	collector.connectTo(&queue);
	queue.connectTo(&printer);

	printer.start();
	queue.start();
	collector.start();

	msg(MSG_DIALOG, "Hit Ctrl+C to quit");
	pause();
	msg(MSG_DIALOG, "Stopping threads and tidying up.\n");

	msg(MSG_DIALOG, "stopping collector\n");
	collector.shutdown();
	queue.shutdown();
	printer.shutdown();

	return 0;
}

void factor_vm::collect_aging() {
  /* Promote objects referenced from tenured space to tenured space, copy
     everything else to the aging semi-space, and reset the nursery pointer. */
  {
    /* Change the op so that if we fail here, an assertion will be
       raised. */
    current_gc->op = collect_to_tenured_op;

    to_tenured_collector collector(this);

    gc_event* event = current_gc->event;

    if (event)
      event->started_card_scan();
    collector.trace_cards(data->tenured, card_points_to_aging, 0xff);
    if (event)
      event->ended_card_scan(collector.cards_scanned, collector.decks_scanned);

    if (event)
      event->started_code_scan();
    collector.trace_code_heap_roots(&code->points_to_aging);
    if (event)
      event->ended_code_scan(collector.code_blocks_scanned);

    collector.visitor.visit_mark_stack(&mark_stack);
  }
  {
    /* If collection fails here, do a to_tenured collection. */
    current_gc->op = collect_aging_op;

    std::swap(data->aging, data->aging_semispace);
    data->reset_aging();

    copying_collector<aging_space, aging_policy> collector(this,
                                                           this->data->aging,
                                                           aging_policy(this));

    collector.visitor.visit_all_roots();
    collector.cheneys_algorithm();

    data->reset_nursery();
    code->clear_remembered_set();
  }
}

void LayerCache::collect(const Rect& viewport, std::vector<int32_t>& index_list) {
    CacheTree::Node * node = m_tree->find_container(viewport);
    CacheTreeCollector collector(index_list, viewport);
    node->apply_visitor(collector);
    node = node->parent();
    while(node) {
        collector.visit(node);
        node = node->parent();
    }
}

/*
 * Class:     mapnik_FeatureTypeStyle
 * Method:    collectAttributes
 * Signature: ()Ljava/util/Set;
 */
JNIEXPORT jobject JNICALL Java_mapnik_FeatureTypeStyle_collectAttributes
  (JNIEnv *env, jobject styleobject)
{
	PREAMBLE;
	mapnik::feature_type_style* style=LOAD_FEATURE_TYPE_STYLE_POINTER(styleobject);
	const std::vector<mapnik::rule>& rules(style->get_rules());

	std::set<std::string> attrs;
	mapnik::attribute_collector collector(attrs);
	for (mapnik::rule const& r : rules) {
		collector(r);
	}


	jobject ret=env->NewObject(CLASS_HASHSET, CTOR_HASHSET);
	for (std::set<std::string>::iterator iter=attrs.begin(); iter!=attrs.end(); iter++) {
		env->CallBooleanMethod(ret, METHOD_HASHSET_ADD, env->NewStringUTF(iter->c_str()));
	}

	return ret;
	TRAILER(0);
}

//--------------------------------------------------------------------------------------------------------
void CFuncNavBlocker::UpdateBlocked()
{
	NavAreaCollector collector( true );
	Extent extent;
	extent.Init( this );
	TheNavMesh->ForAllAreasOverlappingExtent( collector, extent );

	for ( int i=0; i<collector.m_area.Count(); ++i )
	{
		CNavArea *area = collector.m_area[i];
		area->UpdateBlocked( true );
	}

}

int main(int argc, char *argv[]) {

	int lport = DEFAULT_LISTEN_PORT;

	msg_setlevel(MSG_DEFAULT);

	signal(SIGINT, sigint);

	if(argv[1]) {
		lport=atoi(argv[1]);
	}

	// needs to be a pointer because its freed in d'tor of IpfixCollector
	IpfixReceiverUdpIpV4* ipfixReceiver = new IpfixReceiverUdpIpV4(lport);
	IpfixCollector collector(ipfixReceiver);
	ConnectionQueue<IpfixRecord*> queue(100);
	IpfixPrinter printer;

	collector.connectTo(&queue);
	queue.connectTo(&printer);

	printer.start();
	queue.start();
	collector.start();





	// FIXME: test temporarily deactivated
	/*IpfixParser ipfixParser;
	ipfixParser.addFlowSink(&ipfixPrinter);

	IpfixCollector ipfixCollector;
	ipfixCollector.addIpfixReceiver(&ipfixReceiver);
	ipfixCollector.addIpfixPacketProcessor(&ipfixParser);
	ipfixCollector.start();*/

	msg(MSG_DIALOG, "Listening on %d. Hit Ctrl+C to quit\n", lport);
	pause();
	msg(MSG_DIALOG, "Stopping threads and tidying up.\n");

	collector.shutdown();
	queue.shutdown();
	printer.shutdown();


	return 0;
}

void LLViewerControlListener::vars(LLSD const & request)
{
	// This method doesn't use Info, because we're not looking up a specific
	// control name.
	Response response(LLSD(), request);
	std::string groupname(request["group"]);
	LLControlGroup* group(LLControlGroup::getInstance(groupname));
	if (! group)
	{
		return response.error(STRINGIZE("Unrecognized group '" << groupname << "'"));
	}

	CollectVars collector(group);
	group->applyToAll(&collector);
	response["vars"] = collector.vars;
}