// This method is called after the password was successfully stored into the
// QKeyChain in CredentialStore.
void MirallConfigFile::clearPasswordFromConfig( const QString& connection )
{
    const QString file = configFile();
    QString con( defaultConnection() );
    if( !connection.isEmpty() )
        con = connection;

    QSettings settings( file, QSettings::IniFormat);
    settings.setIniCodec( "UTF-8" );
    settings.beginGroup( con );
    settings.remove(QLatin1String("passwd"));
    settings.remove(QLatin1String("password"));
    settings.sync();
}

void dfs(int x){
 if(x == 3) 
  x = 3;
 int u = 0;
 ++top;stk[top] = x;
 while(top - (1<<u) > 0) {f[x][u] = stk[top-(1<<u)]; ++u; }
 rt[x] = rt[f[x][0]];
 add(con(x),a[lk[fa[x]].x].v,double(a[lk[fa[x]].x].w)*double(lk[fa[x]].len));
 TRA(i,x){
   lk[i^1].f = 1;
   fa[lk[i].v] = i;
   dep[lk[i].v] = dep[x]+1;
   dfs(lk[i].v);
 }

QString MirallConfigFile::ownCloudUser( const QString& connection ) const
{
    QString con( connection );
    if( connection.isEmpty() ) con = defaultConnection();

    QSettings settings( configFile(), QSettings::IniFormat );
    settings.setIniCodec( "UTF-8" );
    settings.beginGroup( con );

    QString user = settings.value( QLatin1String("user") ).toString();
    // qDebug() << "Returning configured owncloud user: " << user;

    return user;
}

void
register_chopper (struct pos *p)
{
  assert (con (p)->fg == CHOPPER
          && chopper_at_pos (p) == NULL);

  struct chopper c;

  int step = con (p)->ext.step & 0x7F;

  c.p = *p;
  c.i = step % CHOPPER_MAX_STEP;
  c.wait = CHOPPER_WAIT;
  c.blood = con (p)->ext.step & 0x80;
  c.inactive = (step > 0);
  c.alert = false;
  c.activate = false;

  chopper =
    add_to_array (&c, 1, chopper, &chopper_nmemb, chopper_nmemb, sizeof (c));

  qsort (chopper, chopper_nmemb, sizeof (c), compare_choppers);
}

char * fun(char *s1,int n1)
{
	char *s2,*s3;
	int i,count=0,j=0,k=0;
	s2=(char *)malloc(sizeof(char)*n1);
	s3=(char *)malloc(sizeof(char)*n1);
	for(i=0;i<n1;i++)
		if(s1[i]==',')
			break;
		else
		{
			count++;
			s2[j++]=s1[i];
		}
		s2[j]='\0';
		for(i=(count+1);s1[i]!='\0';i++)
            s3[k++]=s1[i];
		s3[k]='\0';
	if(con(s2)>con(s3))
		return s2;
	else
	    return s3;
}

void
break_closer_floor (struct pos *p)
{
  struct closer_floor *c = closer_floor_at_pos (p);
  if (! c) return;
  c->broken = true;
  c->pressed = true;
  register_con_undo
    (&undo, p,
     MIGNORE, MIGNORE, -abs (con (p)->ext.event) - 1,
     false, false, false, false,
     CHPOS_BREAK_CLOSER_FLOOR,
     "LOOSE FLOOR BREAKING");
}

void irc::pingcheckfunc()
{
	if (pinged)
	{
		pinged = false;
	}
	else
	{
		qDebug() << "reconnection needed";
		name = name + "_";
		discon();
		con();
	}
}

CofmakerApplication::ApplicationResult * CofmakerApplication::InsertCategory( cofmaker::protocol::request_interface::weak_ptr request )
{
	#ifndef _WIN32
		mongo::scoped_ptr<mongo::ScopedDbConnection> con ( mongo::ScopedDbConnection::getScopedDbConnection ( this->_hostPort ) );
#else
		auto & con = mongo::ScopedDbConnection ( this->_hostPort );
#endif
		try
		{
			if ( this->_haspassword )
			{
				std::string errorMsg;
						#ifndef _WIN32
				if ( !con->get()->auth ( this->_database, this->_username, this->_password, errorMsg ) )
					std::cerr << errorMsg << std::endl;

		#else
				if ( !con->auth ( this->_database, this->_username, this->_password, errorMsg ) )
					std::cerr << errorMsg << std::endl;

		#endif
			}
			mongo::BSONObj entry = mongo::fromjson ( request.lock()->function().parameter ( "data" ).values().front() );
			std::set<std::string> fields;
			entry.getFieldNames ( fields );
			if ( fields.find ( "name" ) == fields.end() )
				throw cofmaker::exception::prorocol_error ( "{\"message\":\" Category name not specified\"}", -1, request.lock()->id() );
			mongo::BSONObjBuilder builder;
			builder.genOID();
			builder.appendElements ( entry );
		#ifndef _WIN32
			con->get()->insert ( this->_database + "." + this->_collectionCategory, builder.obj() );
			auto result = con->get()->query ( this->_database + "." + this->_collectionCategory, BSON ( "name" << entry.getField ( "name" ) ) );
		#else
			con->insert ( this->_database + "." + this->_collectionCategory, builder.obj() );
			auto result = con->query ( this->_database + "." + this->_collectionCategory, BSON ( "name" << entry.getField ( "name" ) ) );
			con.done();
			#endif
			std::string value = this->buildResult ( result );
			return new CofmakerApplication::ApplicationResult ( cofmaker::protocol::status::status_success, value );
		}
		catch ( std::exception & e )
		{
#ifdef _WIN32
			con.done();
#endif
			throw;
		}
	return new CofmakerApplication::ApplicationResult ( cofmaker::protocol::status::status_success, "{}" );
}

void MirallConfigFile::setRemotePollInterval(int interval, const QString &connection )
{
    QString con( connection );
    if( connection.isEmpty() ) con = defaultConnection();

    if( interval < 5000 ) {
        qDebug() << "Remote Poll interval of " << interval << " is below fife seconds.";
        return;
    }
    QSettings settings(configFile(), QSettings::IniFormat);
    settings.beginGroup( con );
    settings.setValue(QLatin1String(remotePollIntervalC), interval );
    settings.sync();
}

void MirallConfigFile::removeConnection( const QString& connection )
{
    QString con( connection );
    if( connection.isEmpty() ) con = defaultConnection();

    qDebug() << "    removing the config file for connection " << con;

    // Currently its just removing the entire config file
    QSettings settings( configFile(), QSettings::IniFormat);
    settings.setIniCodec( "UTF-8" );
    settings.beginGroup( con );
    settings.remove(QString::null);  // removes all content from the group
    settings.sync();
}

EventPresenter::EventPresenter(
        const EventModel& model,
        QGraphicsObject* parentview,
        QObject* parent) :
    NamedObject {"EventPresenter", parent},
    m_model {model},
    m_view {new EventView{*this, parentview}},
    m_dispatcher{iscore::IDocument::documentContext(m_model).commandStack}
{
    // The scenario catches this :
    con(m_model.selection, &Selectable::changed,
        m_view, &EventView::setSelected);

    con(m_model.metadata, &ModelMetadata::colorChanged,
        m_view, &EventView::changeColor);

    con(m_model.metadata, &ModelMetadata::commentChanged,
        m_view, &EventView::changeToolTip);

    con(m_model, &EventModel::statusChanged,
        m_view, &EventView::setStatus);

    connect(m_view, &EventView::eventHoverEnter,
            this, &EventPresenter::eventHoverEnter);

    connect(m_view, &EventView::eventHoverLeave,
            this, &EventPresenter::eventHoverLeave);

    connect(m_view, &EventView::dropReceived,
            this, &EventPresenter::handleDrop);

    m_view->setCondition(m_model.condition().toString());
    m_view->setToolTip(m_model.metadata.comment());

    con(m_model, &EventModel::conditionChanged,
        this, [&] (const State::Condition& c) { m_view->setCondition(c.toString()); });
}

int main(int argc, char** argv){
  NDB_INIT(argv[0]);
  load_defaults("my",load_default_groups,&argc,&argv);
  int ho_error;
  if ((ho_error=handle_options(&argc, &argv, my_long_options,
			       ndb_std_get_one_option)))
    return NDBT_ProgramExit(NDBT_WRONGARGS);
  if (argc < 1) {
    usage();
    return NDBT_ProgramExit(NDBT_WRONGARGS);
  }

  Ndb_cluster_connection con(opt_connect_str);
  con.set_name("ndb_drop_table");
  if(con.connect(12, 5, 1) != 0)
  {
    ndbout << "Unable to connect to management server." << endl;
    return NDBT_ProgramExit(NDBT_FAILED);
  }
  if (con.wait_until_ready(30,3) < 0)
  {
    ndbout << "Cluster nodes not ready in 30 seconds." << endl;
    return NDBT_ProgramExit(NDBT_FAILED);
  }

  Ndb MyNdb(&con, _dbname );
  if(MyNdb.init() != 0){
    ERR(MyNdb.getNdbError());
    return NDBT_ProgramExit(NDBT_FAILED);
  }
  
  int res = 0;
  for(int i = 0; i<argc; i++){
    ndbout << "Dropping table " <<  argv[i] << "...";
    int tmp;
    if((tmp = MyNdb.getDictionary()->dropTable(argv[i])) != 0){
      ndbout << endl << MyNdb.getDictionary()->getNdbError() << endl;
      res = tmp;
    } else {
      ndbout << "OK" << endl;
    }
  }
  
  if(res != 0){
    return NDBT_ProgramExit(NDBT_FAILED);
  }
  
  return NDBT_ProgramExit(NDBT_OK);
}

int main(int argc, char** argv){
  NDB_INIT(argv[0]);
  load_defaults("my",load_default_groups,&argc,&argv);
  int ho_error;
#ifndef DBUG_OFF
  opt_debug= "d:t:O,/tmp/ndb_delete_all.trace";
#endif
  if ((ho_error=handle_options(&argc, &argv, my_long_options,
			       ndb_std_get_one_option)))
    return NDBT_ProgramExit(NDBT_WRONGARGS);

  Ndb_cluster_connection con(opt_connect_str);
  con.set_name("ndb_delete_all");
  if(con.connect(12, 5, 1) != 0)
  {
    ndbout << "Unable to connect to management server." << endl;
    return NDBT_ProgramExit(NDBT_FAILED);
  }
  if (con.wait_until_ready(30,0) < 0)
  {
    ndbout << "Cluster nodes not ready in 30 seconds." << endl;
    return NDBT_ProgramExit(NDBT_FAILED);
  }

  Ndb MyNdb(&con, _dbname );
  if(MyNdb.init() != 0){
    ERR(MyNdb.getNdbError());
    return NDBT_ProgramExit(NDBT_FAILED);
  }
  
  // Check if table exists in db
  int res = NDBT_OK;
  for(int i = 0; i<argc; i++){
    const NdbDictionary::Table * pTab = NDBT_Table::discoverTableFromDb(&MyNdb, argv[i]);
    if(pTab == NULL){
      ndbout << " Table " << argv[i] << " does not exist!" << endl;
      return NDBT_ProgramExit(NDBT_WRONGARGS);
    }
    ndbout << "Deleting all from " << argv[i];
    if (! _transactional)
      ndbout << " (non-transactional)";
    ndbout << " ...";
    if(clear_table(&MyNdb, pTab, ! _transactional) == NDBT_FAILED){
      res = NDBT_FAILED;
      ndbout << "FAILED" << endl;
    }
  }
  return NDBT_ProgramExit(res);
}

int main()
{
	//toprsImg img;
    int test = 5;
	
	toprsConnAble<toprsConnAbleReader> * pb = toprsConnAble<toprsConnAbleReader>::getInstance();
	toprsConnAble<toprsConnAbleFilter> * pd = toprsConnAble<toprsConnAbleFilter>::getInstance();
	////toprsConnAble * pc = toprsConnAble<toprsConnAbleReader>::getInstance();


	bool x = pb->canConnectMyInputTo(&test);

	bool y = pd->canConnectMyInputTo(&test);

	std::shared_ptr<testinter> temp(new testinter);
	std::shared_ptr<testinter> temp2 = std::make_shared<testinter>();

	toprsConnection<testinter> con(temp);
	con.connectMyInputTo(temp2);
	
	toprsConnection<testinter> con2(con);

	toprsConnection<testinter> con3(std::move(con));





	//bool z = con.testt<toprsConnAbleFilter>(&test);

	//toprsConnection<int> theConn(&test);

	//int one = 1;
	//int two =2;
	//int three = 3;

	//theConn.start();
   // theConn>>one>>two>>three;

	
	

	//bool z = pc->canConnectMyInputTo(&test);


	//return 0;
	//toprsConnAble<toprsConnAbleReader>* r = toprsConnAbleReader::getInstance();
	return 0;
}

void
shake_loose_floor_row (struct pos *p)
{
  struct pos _p = *p;

  struct loose_floor *l;
  for (_p.place = PLACES - 1; _p.place >= -1; _p.place--)
    if (con (&_p)->fg == LOOSE_FLOOR) {
      l = loose_floor_at_pos (&_p);
      if (l->action == NO_LOOSE_FLOOR_ACTION) {
        l->action = SHAKE_LOOSE_FLOOR;
        l->i = 0;
      }
    }
}

		bool submit(client::destination_container sender, client::destination_container target, const Plugin::SubmitRequestMessage &request_message, Plugin::SubmitResponseMessage &response_message) {
			const ::Plugin::Common_Header& request_header = request_message.header();
			nscapi::protobuf::functions::make_return_header(response_message.mutable_header(), request_header);
			connection_data con(target, sender);

			std::list<collectd::packet> list;
			for (int i = 0; i < request_message.payload_size(); ++i) {
				collectd::packet packet;
				//packet.add_string(0, "Hello WOrld");
				list.push_back(packet);
			}

			send(response_message.add_payload(), con, list);
			return true;
		}

int dps(int i, int j) {
	if (i <= 0) return 0;
	i64 &g = f[i][j];
	if (g != -1) return g;
	g = con(i, j);
	g += dps(i - 2, j);
	for (int k = 1; k < i - 1; ++k)
		for (int l = 0; l < m; ++l) {
			g += (i64)dps(k, l) * dps(i - 1 - k - 2, (j - l + m) % m) % mod;
			g += (i64)dps(k, l) * h[i - 1 - k][(j - l + m) % m] % mod;
			g += (i64)dps(k, l) * dps(i - 1 - k - 2, (l - j + m) % m) % mod;
			g += (i64)dps(k, l) * h[i - 1 - k][(l - j + m) % m] % mod;
		}
	return g %= mod;
}

int main(int argc, char* argv[])
{
    if(argc != 2)
    {
        return -1;
    }

    QDir().mkdir("output");
    QDir output_dir("output");

    sqlite::connection con(QString::fromLocal8Bit(argv[1]).toStdString());
    iterateThreads(con, output_dir);

    return 0;
}

void ConfigFile::setRemotePollInterval(chrono::milliseconds interval, const QString &connection)
{
    QString con(connection);
    if (connection.isEmpty())
        con = defaultConnection();

    if (interval < chrono::seconds(5)) {
        qCWarning(lcConfigFile) << "Remote Poll interval of " << interval.count() << " is below five seconds.";
        return;
    }
    QSettings settings(configFile(), QSettings::IniFormat);
    settings.beginGroup(con);
    settings.setValue(QLatin1String(remotePollIntervalC), qlonglong(interval.count()));
    settings.sync();
}

int ConfigFile::remotePollInterval( const QString& connection ) const
{
  QString con( connection );
  if( connection.isEmpty() ) con = defaultConnection();

  QSettings settings(configFile(), QSettings::IniFormat);
  settings.beginGroup( con );

  int remoteInterval = settings.value( QLatin1String(remotePollIntervalC), DEFAULT_REMOTE_POLL_INTERVAL ).toInt();
  if( remoteInterval < 5000) {
    qDebug() << "Remote Interval is less than 5 seconds, reverting to" << DEFAULT_REMOTE_POLL_INTERVAL;
    remoteInterval = DEFAULT_REMOTE_POLL_INTERVAL;
  }
  return remoteInterval;
}