/** attempt to transform this controller into a spatialization
    controller and connect to the given module's spatialization
    control inputs. Returns true on success, false if given module
    does not accept spatialization inputs. */
bool
Controller_Module::connect_spatializer_to ( Module *m )
{
    connect_spatializer_radius_to( m );
    
    /* these are for detecting related parameter groups which can be
       better represented by a single control */
    Port *azimuth_port = NULL;
    float azimuth_value = 0.0f;
    Port *elevation_port = NULL;
    float elevation_value = 0.0f;

    for ( unsigned int i = 0; i < m->control_input.size(); ++i )
    {
        Port *p = &m->control_input[i];

        if ( !strcasecmp( "Azimuth", p->name() ) &&
             180.0f == p->hints.maximum &&
             -180.0f == p->hints.minimum )
        {
            azimuth_port = p;
            azimuth_value = p->control_value();
            continue;
        }
        else if ( !strcasecmp( "Elevation", p->name() ) &&
                  90.0f == p->hints.maximum &&
                  -90.0f == p->hints.minimum )
        {
            elevation_port = p;
            elevation_value = p->control_value();
            continue;
        }
    }
    
    if ( ! ( azimuth_port && elevation_port ) )
        return false;

    if ( control_output.size() != 3 )
    {
        control_output.clear();
        add_port( Port( this, Port::OUTPUT, Port::CONTROL ) );
        add_port( Port( this, Port::OUTPUT, Port::CONTROL ) );
        add_port( Port( this, Port::OUTPUT, Port::CONTROL ) );
    }

    control_output[0].connect_to( azimuth_port );
    control_output[1].connect_to( elevation_port );

    maybe_create_panner();
    
    Panner *o = (Panner*)control;

    o->point( 0 )->azimuth( azimuth_value );
    o->point( 0 )->elevation( elevation_value );
   
    if ( Mixer::spatialization_console )
        Mixer::spatialization_console->update();

    return true;
}

BString
BNetworkAddress::ToString(bool includePort) const
{
	char buffer[512];

	switch (fAddress.ss_family) {
		case AF_INET:
			inet_ntop(AF_INET, &((sockaddr_in&)fAddress).sin_addr, buffer,
				sizeof(buffer));
			break;

		case AF_INET6:
			inet_ntop(AF_INET6, &((sockaddr_in6&)fAddress).sin6_addr,
				buffer, sizeof(buffer));
			break;

		case AF_LINK:
		{
			uint8 *byte = LinkLevelAddress();
			char* target = buffer;
			int bytesLeft = sizeof(buffer);
			target[0] = '\0';

			for (size_t i = 0; i < LinkLevelAddressLength(); i++) {
				if (i != 0 && bytesLeft > 1) {
					target[0] = ':';
					target[1] = '\0';
					target++;
					bytesLeft--;
				}

				int bytesWritten = snprintf(target, bytesLeft, "%02x", byte[i]);
				if (bytesWritten >= bytesLeft)
					break;

				target += bytesWritten;
				bytesLeft -= bytesWritten;
			}
			break;
		}

		default:
			return "";
	}

	BString address = buffer;
	if (includePort && Port() != 0) {
		if (fAddress.ss_family == AF_INET6) {
			address = "[";
			address += buffer;
			address += "]";
		}

		snprintf(buffer, sizeof(buffer), ":%u", Port());
		address += buffer;
	}

	return address;
}

		std::string IPv4EndPoint::ToString() const
		{
			auto field = (uint8_t*)_Addr.Field();
			auto rv = std::to_string(field[4]) + '.' + std::to_string(field[5]) + '.' + std::to_string(field[6]) + '.' + std::to_string(field[7]);
			if (Port() != 0)
				rv += ':' + Port();
			return rv;
		}

void TExternalProgramFx::addPort(std::string portName, std::string ext,
                                 bool isInput) {
  if (isInput) {
    TRasterFxPort *port = new TRasterFxPort();
    m_ports[portName]   = Port(portName, ext, port);
    addInputPort(portName, *port);
  } else
    m_ports[portName] = Port(portName, ext, 0);
}

	// -------------------------- Pixel --------------------------
	Pixel::Pixel(uint8_t number_of_vertex) {
		// プロトタイプ2号のピン配置
		this->ports.push_back(Port(new skInfraredCOM(2, 11), 0));
		this->ports.push_back(Port(new skInfraredCOM(3, 12), 0));
		this->ports.push_back(Port(new skInfraredCOM(4, 13), 0));

		this->configured = false;
		this->device_id = 0;
		this->number_of_vertex = number_of_vertex;
		this->led = Adafruit_NeoPixel(1, 10, NEO_GRB + NEO_KHZ800);
		this->led.begin();
	}

//_________________________________________________________
void SendEvents1 (short refNum)
{
	SlotPtr slot = 0;
	MidiEvPtr e;
	
	while ((e = MidiGetEv (refNum))) {
		if (!slot || (Slot(slot->refNum) != Port(e)))
			slot = FindSlot(gOutSlots, Port(e));
		if (slot) {
			if (!MS2MM (refNum, slot, e)) return; 
		}else{
			MidiFreeEv(e);
		}
	}
}

Meter_Indicator_Module::Meter_Indicator_Module ( bool is_default )
    : Module ( is_default, 50, 100, name() )
{
    box( FL_FLAT_BOX );
    color( FL_BLACK );

    _disable_context_menu = false;
    _pad = true;
    control_value = 0;

    add_port( Port( this, Port::INPUT, Port::CONTROL ) );

    control_input[0].hints.visible = false;

    dpm_pack = new Fl_Scalepack( x(), y(), w(), h() );
    dpm_pack->color( FL_BACKGROUND_COLOR );
    dpm_pack->box( FL_FLAT_BOX );
    dpm_pack->type( FL_HORIZONTAL );

    end();

    control_value = new float[1];
    *control_value = -70.0f;

    align( (Fl_Align)(FL_ALIGN_CENTER | FL_ALIGN_INSIDE ) );

    clear_visible_focus();
}

//_____________________________________________________________________________
// port and channel parsing
//_____________________________________________________________________________
static MidiEvPtr rcvPort (UDPStreamPtr f, Byte c)
{
	f->length--;
	Port(f->ptrCur) = c;
	f->parse = rcvChan;
	return 0;
}

DummyDevPackedVector4::DummyDevPackedVector4(const DeviceConfig & deviceConfig) {

    this->deviceDescriptor.setEntityID(deviceConfig.getEntityID());
    this->entityID = this->deviceDescriptor.getEntityID();

    map<string, Port> portMap;

    portMap["pv1"] = Port("pv1", "PackedVector4", Port::Source, "");

    DeviceType deviceType;
    deviceType.setPortMap(portMap);
    deviceType.setDeviceTypeName("DummyDevPackedVector4");
    deviceType.setDescription("");

    this->deviceDescriptor.setDeviceType(deviceType);

    std::map<std::string, int> nameChannelNrMap;
    int nr = 1;
    map<string, Port>::iterator i = portMap.begin();
    map<string, Port>::iterator e = portMap.end();
    while (i != e) {
        nameChannelNrMap[(*i).second.getName()] = nr;
        ++nr;
        ++i;
    }
    this->deviceDescriptor.setNameChannelNrMap(nameChannelNrMap);
}

/*____________________________________________________________________*/
static void TestPort( int i)
{
	MidiEvPtr e;
	int n, result= true;
	
	for( n=0; n<LastPort; n++) {
		e= MidiNewEv( typeKeyOn);
		if( e) {
			Port(e)= n;
			MidiSendIm( refNum, e);
			wait( 2);
			e= GetReceived();
			if( e) {
				if( n== i) {
					print ("\n    error: port %d not filtered\n", n);
					result= false;
				}
				MidiFreeEv( e);
			}
			else if( n!= i) {
				print ("\n    error: port %d filtered\n", n);
				result= false;
			}
		}
		else {
			print ("\n  cannot allocate a new event !\n");
			break;
		}
	}
	if( result) print ("ok\n");
}

status_t
BNetworkAddress::ResolveForDestination(const BNetworkAddress& destination)
{
	if (!IsWildcard())
		return B_OK;
	if (destination.fAddress.ss_family != fAddress.ss_family)
		return B_BAD_VALUE;

	char buffer[2048];
	memset(buffer, 0, sizeof(buffer));

	route_entry* route = (route_entry*)buffer;
	route->destination = (sockaddr*)&destination.fAddress;

	int socket = ::socket(fAddress.ss_family, SOCK_DGRAM, 0);
	if (socket < 0)
		return errno;

	if (ioctl(socket, SIOCGETRT, route, sizeof(buffer)) != 0) {
		close(socket);
		return errno;
	}

	uint16 port = Port();
	memcpy(&fAddress, route->source, sizeof(sockaddr_storage));
	SetPort(port);

	close(socket);
	return B_OK;
}

bool
BNetworkAddress::Equals(const BNetworkAddress& other, bool includePort) const
{
	if (IsEmpty() && other.IsEmpty())
		return true;

	if (Family() != other.Family()
			|| (includePort && Port() != other.Port())) {
		return false;
	}

	switch (fAddress.ss_family) {
		case AF_INET:
		{
			sockaddr_in& address = (sockaddr_in&)fAddress;
			sockaddr_in& otherAddress = (sockaddr_in&)other.fAddress;
			return memcmp(&address.sin_addr, &otherAddress.sin_addr,
				sizeof(address.sin_addr)) == 0;
		}

		case AF_INET6:
		{
			sockaddr_in6& address = (sockaddr_in6&)fAddress;
			sockaddr_in6& otherAddress = (sockaddr_in6&)other.fAddress;
			return memcmp(&address.sin6_addr, &otherAddress.sin6_addr,
				sizeof(address.sin6_addr)) == 0;
		}

		default:
			if (fAddress.ss_len != other.fAddress.ss_len)
				return false;

			return memcmp(&fAddress, &other.fAddress, fAddress.ss_len);
	}
}

	void PortList::addNewPort(bt::Uint16 number,Protocol proto,bool forward)
	{
		Port p = Port(number,proto,forward);
		append(p);
		if (lst)
			lst->portAdded(p);
	}

PortSet PortsManager::GetNowPorts()
{
	PortSet newPorts;

	PMIB_TCPTABLE pTcpTable;
	DWORD dwSize = 0;
	DWORD dwRetVal = 0;
	unsigned short *port_ptr;
	DWORD i;

	/* Get size required by GetTcpTable() */
	if (GetTcpTable(NULL, &dwSize, 0) == ERROR_INSUFFICIENT_BUFFER) {
		pTcpTable = (MIB_TCPTABLE *) malloc (dwSize);
	}

	/* Get actual data using GetTcpTable() */
	if ((dwRetVal = GetTcpTable(pTcpTable, &dwSize, 0)) == NO_ERROR) {
		if (pTcpTable->dwNumEntries > 0) {
			for (i=0; i<pTcpTable->dwNumEntries; i++) {
				//addr_ptr = (char *)&pTcpTable->table[i].dwLocalAddr;
				//port_ptr = (unsigned short *)&pTcpTable->table[i].dwLocalPort;
				//addr_ptr = (char *)&pTcpTable->table[i].dwRemoteAddr;
				port_ptr = (unsigned short *)&pTcpTable->table[i].dwRemotePort;
				DWORD state = pTcpTable->table[i].dwState;
				newPorts.insert(Port(*port_ptr, state));
			}
		}
	}
	free(pTcpTable);
	return newPorts;
}

void
nsHttpConnectionInfo::SetOriginServer(const nsACString &host, int32_t port)
{
    mHost = host;
    mPort = port == -1 ? DefaultPort() : port;

    //
    // build hash key:
    //
    // the hash key uniquely identifies the connection type.  two connections
    // are "equal" if they end up talking the same protocol to the same server
    // and are both used for anonymous or non-anonymous connection only;
    // anonymity of the connection is setup later from nsHttpChannel::AsyncOpen
    // where we know we use anonymous connection (LOAD_ANONYMOUS load flag)
    //

    const char *keyHost;
    int32_t keyPort;

    if (mUsingHttpProxy && !mUsingConnect) {
        keyHost = ProxyHost();
        keyPort = ProxyPort();
    }
    else {
        keyHost = Host();
        keyPort = Port();
    }

    mHashKey.AssignLiteral("....");
    mHashKey.Append(keyHost);
    mHashKey.Append(':');
    mHashKey.AppendInt(keyPort);

    if (mUsingHttpProxy)
        mHashKey.SetCharAt('P', 0);
    if (mUsingSSL)
        mHashKey.SetCharAt('S', 1);

    // NOTE: for transparent proxies (e.g., SOCKS) we need to encode the proxy
    // info in the hash key (this ensures that we will continue to speak the
    // right protocol even if our proxy preferences change).
    //
    // NOTE: for SSL tunnels add the proxy information to the cache key.
    // We cannot use the proxy as the host parameter (as we do for non SSL)
    // because this is a single host tunnel, but we need to include the proxy
    // information so that a change in proxy config will mean this connection
    // is not reused

    if ((!mUsingHttpProxy && ProxyHost()) ||
        (mUsingHttpProxy && mUsingConnect)) {
        mHashKey.AppendLiteral(" (");
        mHashKey.Append(ProxyType());
        mHashKey.Append(':');
        mHashKey.Append(ProxyHost());
        mHashKey.Append(':');
        mHashKey.AppendInt(ProxyPort());
        mHashKey.Append(')');
    }
}

/**
 * Compares two addresses.
 * Invalid addresses always compare the same, and below anything else.
 * IPv4 addresses always compare smaller than IPv6.
 * Assumes that IPv4 Addresses are in network order.
 *
 * If is IPv6 then comparison is:
 *    sin6_addr
 *    sin6_scope_id
 *    sin6_port
 *    sin6_flowinfo
 *
 * If is IPv4 then comparison is:
 *    sin_addr
 *    sin_port
 *
 * @param rhs
 *
 * @return: -1, 0, or 1 like strcmp.
 */
int sockAddrBase::compare(const sockAddrBase &rhs, bool comparePort) const
{
  if (Type() != rhs.Type())
  {
    if (!IsValid())
      return -1;
    if (!rhs.IsValid())
      return 1;
    if (IsIPv4())
      return -1;
    // We must be IPv6
    return 1;
  }

  if (!IsValid())
    return 0;
  if (IsIPv4())
  {
    in_addr_t addrLhs = getIPv4Storage()->sin_addr.s_addr;
    in_addr_t addrRhs = rhs.getIPv4Storage()->sin_addr.s_addr;

    if (addrLhs == addrRhs)
    {
      if (!comparePort || Port() == rhs.Port())
        return 0;
      return Port() > rhs.Port() ? 1 : -1;
    }
    return ntohl(addrLhs) > ntohl(addrRhs) ? 1 : -1;
  }
  else
  {
    // IPv6
    const sockaddr_in6 *storageLhs = getIPv6Storage();
    const sockaddr_in6 *storageRhs = rhs.getIPv6Storage();
    int val = memcmp(&storageLhs->sin6_addr, &storageRhs->sin6_addr, sizeof(in6_addr));
    if (val != 0)
      return val;
    if (storageLhs->sin6_scope_id != storageRhs->sin6_scope_id)
      return ntohl(storageLhs->sin6_scope_id) > ntohl(storageRhs->sin6_scope_id) ? 1 : -1;
    if (comparePort && Port() != rhs.Port())
      return Port() > rhs.Port() ? 1 : -1;
    if (storageLhs->sin6_flowinfo != storageRhs->sin6_flowinfo)
      return ntohl(storageLhs->sin6_flowinfo) > ntohl(storageRhs->sin6_flowinfo) ? 1 : -1;
    return 0;
  }
}

static inline void LinearizeCommon (int i, MidiEvPtr e, Ev2UDPStreamPtr f)
{
	f->data[i--] = EvType(e);
	LinearizeDate (i, e, f);
	i -= kDateSize;
	f->data[i--] = Port(e);
	f->data[i] = Chan(e);
}

bool
Controller_Module::connect_spatializer_radius_to ( Module *m )
{
    Port *radius_port = NULL;
    float radius_value = 0.0f;

    for ( unsigned int i = 0; i < m->control_input.size(); ++i )
    {
        Port *p = &m->control_input[i];

        if ( !strcasecmp( "Radius", p->name() ) )
                  /* 90.0f == p->hints.maximum && */
                  /* -90.0f == p->hints.minimum ) */
        {
            radius_port = p;
            radius_value = p->control_value();
            continue;
        }
    }

    if ( ! radius_port )
        return false;

    if ( control_output.size() != 3 )
    {
        control_output.clear();
        add_port( Port( this, Port::OUTPUT, Port::CONTROL ) );
        add_port( Port( this, Port::OUTPUT, Port::CONTROL ) );
        add_port( Port( this, Port::OUTPUT, Port::CONTROL ) );
    }

    
    control_output[2].connect_to( radius_port );

    maybe_create_panner();
    
    Panner *o = (Panner*)control;

    o->point( 0 )->radius( radius_value );
   
    if ( Mixer::spatialization_console )
        Mixer::spatialization_console->update();

    return true;
}

//_________________________________________________________
void SendEvents2 (short refNum)
{
	SlotPtr slot = 0;
	MidiEvPtr e;
	
	while ((e = MidiGetEv (refNum))) {
		if (!slot || (Slot(slot->refNum) != Port(e)))
			slot = FindSlot(gOutSlots, Port(e));
		if (slot) {
			if (!MS2MM (refNum, slot, e)) return;  // A SysEx is sent 
		}else{
			MidiFreeEv(e);
		}
	}
	
	MidiSetRcvAlarm(refNum,RcvAlarm);
	MidiSendIm(refNum, MidiNewEv(typeRestart));
}

	void PortList::removePort(bt::Uint16 number,Protocol proto)
	{
		PortList::iterator itr = qFind(begin(),end(),Port(number,proto,false));
		if (itr == end())
			return;
		
		if (lst)
			lst->portRemoved(*itr);
		
		erase(itr);
	}