/*
 	interface is optional. If NULL, then all interfaces will be used
*/
FskErr FskHTTPServerCreate(int port, char *interfaceName, FskHTTPServer *server, void *refCon, Boolean ssl) {
	FskHTTPServer	http;
	FskErr err;

	FskInstrumentedTypePrintfDebug(&gFskHTTPServerTypeInstrumentation, "httpServerCreate\n");
	err = FskMemPtrNewClear(sizeof(FskHTTPServerRecord), (FskMemPtr*)&http);
	BAIL_IF_ERR(err);

	sFskHTTPServerUpUse(http);

	http->stopped = true;
	http->refCon = refCon;
	http->port = port;
	http->keepAliveTimeout = kFskHTTPKeepAliveTimeout;
	http->defaultBufferSize = kFskHTTPServerDefaultBufferSize;
	http->owner = FskThreadGetCurrent();
	http->ssl = ssl;

	snprintf(http->name, 64, "%s:%d", interfaceName ? interfaceName : "all", port);
	FskInstrumentedItemNew(http, http->name, &gFskHTTPServerTypeInstrumentation);

	if (interfaceName) {
		err = FskHTTPServerListenerAdd(http, port, interfaceName, NULL);
	}
	else {
		FskNetInterfaceRecord *ifc;
		int i, numI;
		http->all = true;
		numI = FskNetInterfaceEnumerate();
		for (i=0; i<numI; i++) {
			FskErr notErr = FskNetInterfaceDescribe(i, &ifc);
			if (notErr) continue;
			if (ifc->status) {
				notErr = FskHTTPServerListenerAdd(http, port, ifc->name, NULL);
				if (notErr) err = notErr;
			}
			FskNetInterfaceDescriptionDispose(ifc);
		}
	}

	http->interfaceNotifier = FskNetInterfaceAddNotifier(httpServerInterfaceChanged, http, "http server");

bail:
	*server = http;
	return err;
}

 FskErr amrReaderNew(FskMediaReader reader, void **readerState, const char *mimeType, const char *uri, FskMediaSpooler spooler)
{
	FskErr err;
	amrReader state = NULL;

    BAIL_IF_NULL(spooler, err, kFskErrUnimplemented);
	
	err = FskMemPtrNewClear(sizeof(amrReaderRecord), &state);
	BAIL_IF_ERR(err);

	*readerState = state;			// must be set before anything that might issue a callback
	state->spooler = spooler;
	state->reader = reader;

	if (spooler->doOpen) {
		err = (spooler->doOpen)(spooler, kFskFilePermissionReadOnly);
		BAIL_IF_ERR(err);

		state->spoolerOpen = true;
	}

	state->spooler->onSpoolerCallback = amrSpoolerCallback;
	state->spooler->clientRefCon = state;
	state->spooler->flags |= kFskMediaSpoolerForwardOnly;

	state->duration = kFskUInt32Max;

	(reader->doSetState)(reader, kFskMediaPlayerStateInstantiating);

	err = amrInstantiate(state);
	if (err) {
		if (kFskErrNeedMoreTime == err)
			err = kFskErrNone;
		goto bail;
	}

bail:
	if ((kFskErrNone != err) && (NULL != state)) {
		amrReaderDispose(reader, state);
		state = NULL;
	}

	*readerState = state;

	return err;
}

FskErr KprSSDPClientNew(KprSSDPClient *it, const char* type)
{
	FskErr err = kFskErrNone;
	KprSSDPClient self = NULL;

	bailIfError(FskMemPtrNewClear(sizeof(KprSSDPClientRecord), it));
	self = *it;
	if (type) {
		self->type = FskStrDoCopy(type);
		bailIfNULL(self->type);
	}
	FskInstrumentedItemNew(self, NULL, &KprSSDPClientInstrumentation);
bail:
	if (err)
		KprSSDPClientDispose(self);
	return err;
}

void scanVolumes() {
	FILE *mountList;
	struct mntent	*cur;
	int err;
	volInfo	vi;
	mntdevmap *walker;
	struct statfs fsinfo;

	mountList = setmntent(kKplLinuxVolumeListFile, "r");
	if (mountList) {
		while (NULL != (cur = getmntent(mountList))) {
			err = statfs(cur->mnt_dir, &fsinfo);
			if (0 != err) {
				continue;
			}

			for (walker = gMntDevMap; NULL != walker->name; walker++) {
				if (0 == FskStrCompareWithLength(cur->mnt_type, walker->name, FskStrLen(walker->name)))
					break;
			}

			if (!walker->name) {
				continue;
			}

			FskMemPtrNewClear(sizeof(volInfoRec), &vi);
			vi->type = walker->type;
			vi->removable = walker->removable;
			vi->mounted = true;
			vi->typeStr = FskStrDoCopy(cur->mnt_type);

			if (kFskErrNone == FskMemPtrNew(FskStrLen(cur->mnt_dir) + 2, &vi->mountPoint)) {
				FskStrCopy(vi->mountPoint, cur->mnt_dir);
				if (vi->mountPoint[FskStrLen(vi->mountPoint)-1] != '/')
					FskStrCat(vi->mountPoint, "/");
			}

			vi->name = copyNiceName(cur->mnt_fsname);
			vi->capacity = fsinfo.f_blocks * fsinfo.f_bsize;
			vi->remaining = fsinfo.f_bavail * fsinfo.f_bsize;
			FskListAppend(&volumeList, vi);
		}
		endmntent(mountList);
	}
}

FskErr lpcmPacketParserProcessPacket(RTPPacketParser parser, RTPPacket rtpHeader)
{
	LPCMPacketParser lpcmPacketParser = (LPCMPacketParser)parser->handlerRefCon;
	RTPCompressedMediaFrame frame;
	FskErr err;

	err = FskMemPtrNewClear(rtpHeader->dataSize + sizeof(RTPCompressedMediaFrameRecord), &frame);
	BAIL_IF_ERR(err);

	rtpHeader->frames = frame;
	frame->length = rtpHeader->dataSize;
	FskMemMove(frame + 1, rtpHeader->data, rtpHeader->dataSize);
	
	rtpHeader->totalSamples = frame->length / (lpcmPacketParser->bitsPerSample/8) / lpcmPacketParser->nChannels;

bail:
	return err;
}

FskErr KprZeroconfServiceNewType(char* authority, char** it)
{
#define kKPRZeroconfKinomaServe "_%s._tcp."
	FskErr err = kFskErrNone;
	char* type = NULL;
	char* ptr;
	UInt32 length = FskStrLen(authority);
	UInt32 size = length + FskStrLen(kKPRZeroconfKinomaServe);
	bailIfError(FskMemPtrNewClear(size, &type));
	snprintf(type, size, kKPRZeroconfKinomaServe, authority);
	type[length + 1] = 0;
	for (ptr = FskStrChr(type, '.'); ptr; ptr = FskStrChr(ptr, '.')) 
		*ptr = '_';
	type[length + 1] = '.';
	*it = type;
bail:
	return err;
}

FskErr KprCanvasNew(KprCanvas* it,  KprCoordinates coordinates)
{
	FskErr err = kFskErrNone;
	KprCanvas self;

	bailIfError(FskMemPtrNewClear(sizeof(KprCanvasRecord), it));
	self = *it;
	FskInstrumentedItemNew(self, NULL, &KprCanvasInstrumentation);
	self->dispatch = &KprCanvasDispatchRecord;
	self->flags = kprVisible;
	KprContentInitialize((KprContent)self, coordinates, NULL, NULL);
	if (coordinates->width && coordinates->height) {
		bailIfError(FskCanvasNew(coordinates->width, coordinates->height, PreferredPixelFormat(), &self->cnv));
        FskCanvas2dSetOpenGLSourceAccelerated(self->cnv, true);
    }
bail:
	return err;
}

FskErr KprWebSocketServerNew(KprWebSocketServer* it, void *refCon)
{
	FskErr err = kFskErrNone;
	KprWebSocketServer self = NULL;

	bailIfError(FskMemPtrNewClear(sizeof(KprWebSocketServerRecord), it));
	self = *it;

	self->stopped = false;
	self->refCon = refCon;
	self->owner = FskThreadGetCurrent();

//	self->interfaceNotifier = FskNetInterfaceAddNotifier(KprWebSocketServerInterfaceChanged, self, "websocket server");
	return err;
bail:
	KprWebSocketServerDispose(self);
	return err;
}

FskErr KprDebugNew(KprDebug* it, UInt32 port)
{
	FskErr err = kFskErrNone;
	KprDebug self = NULL;
	BAIL_IF_ERR(err = FskMemPtrNewClear(sizeof(KprDebugRecord), it));
	self = *it;
	self->port = port;
	BAIL_IF_ERR(err = KprSocketServerNew(&self->server, self));
	self->server->debugName = "Debug";
	self->server->acceptCallback = KprDebugAcceptNewConnection;
	BAIL_IF_ERR(err = KprSocketServerListen(self->server, self->port, NULL));
	FskListAppend(&gKprDebugList, self);
	FskInstrumentedItemNew(self, NULL, &KprDebugInstrumentation);
	return err;
bail:
	KprDebugDispose(self);
	return err;
}

FskErr KprWebSocketEndpointNew(KprWebSocketEndpoint* it, void *refcon)
{
	FskErr err = kFskErrNone;
	KprWebSocketEndpoint self = NULL;
	
	bailIfError(FskMemPtrNewClear(sizeof(KprWebSocketEndpointRecord), it));
	self = *it;
	FskInstrumentedItemNew(self, NULL, &gKprWebSocketEndpointInstrumentation);
	
	self->refcon = refcon;
	self->state = kKprWebSocketStateConnecting;

	FskDebugStr("CREATE: KprWebSocketEndpoint\n");
	return err;
bail:
	if (self) KprWebSocketEndpointDispose(self);
	return err;
}

FskErr FskGtkWindowCreate(FskWindow fskWindow, UInt32 style, SInt32 width, SInt32 height)
{
	FskErr			err = kFskErrNone;
	FskGtkWindow	gtkWin;

	if(fskWindow->gtkWin == NULL) {
		err = FskMemPtrNewClear(sizeof(FskGtkWindowRecord), &(fskWindow->gtkWin));
		BAIL_IF_ERR(err);
	}

	gtkWin = (FskGtkWindow)fskWindow->gtkWin;
	gtkWin->width = width;
	gtkWin->height = height;

	FskGtkWindowInit(fskWindow);
bail:
	return err;
}

FskErr KplConditionNew(KplCondition *conditionOut)
{
    FskErr err;
    KplCondition condition = NULL;

    err = FskMemPtrNewClear(sizeof(KplConditionRecord), (FskMemPtr *)&condition);
    if (err) goto bail;
	pthread_cond_init(&condition->cond, NULL);

bail:
    if (err) {
        KplConditionDispose(condition);
        condition = NULL;
    }
    *conditionOut = condition;

    return err;
}

FskErr FskAudioCompressNew(FskAudioCompress *compOut, const char *outputFormat, const char *inputFormat, UInt32 inputSampleRate, UInt32 inputChannelCount)
{
    FskErr err;
    FskAudioCompressor encoder;
    FskAudioCompress comp;
    UInt32 i = 0;

    while (true) {
        Boolean canHandle = false;
        encoder = (FskAudioCompressor)FskExtensionGetByIndex(kFskExtensionAudioCompressor, i++);
        if (NULL == encoder) {
            *compOut = NULL;
            return kFskErrExtensionNotFound;
        }

        if ((kFskErrNone == encoder->doCanHandle(outputFormat, &canHandle)) && canHandle)
            break;
    }

    err = FskMemPtrNewClear(sizeof(FskAudioCompressRecord), &comp);
    BAIL_IF_ERR(err);

    comp->outputFormat = FskStrDoCopy(outputFormat);
    comp->inputFormat = FskStrDoCopy(inputFormat);
    comp->inputSampleRate = inputSampleRate;
    comp->inputChannelCount = inputChannelCount;

    comp->outputSampleRate = inputSampleRate;
    comp->outputChannelCount = inputChannelCount;

    comp->encoder = encoder;
    err = comp->encoder->doNew(comp);
    BAIL_IF_ERR(err);

bail:
    if (err) {
        FskAudioCompressDispose(comp);
        comp = NULL;
    }
    *compOut = comp;

    return err;
}

void fxLoadModuleJSB(txMachine* the, txString path, txID moduleID)
{
	FskErr err = kFskErrNone;
	txScript* script = NULL;
	FskFile fref = NULL;
	Atom atom;

	bailIfError(FskMemPtrNewClear(sizeof(txScript), &script));
	bailIfError(FskFileOpen(path, kFskFilePermissionReadOnly, &fref));
	bailIfError(fxLoadModuleJSBAtom(the, fref, &atom));
	bailAssert(atom.atomType == XS_ATOM_BINARY);
	
	bailIfError(fxLoadModuleJSBAtom(the, fref, &atom));
	bailAssert(atom.atomType == XS_ATOM_VERSION);
	bailIfError(FskFileRead(fref, sizeof(script->version), script->version, NULL));
	bailAssert(script->version[0] == XS_MAJOR_VERSION);
	bailAssert(script->version[1] == XS_MINOR_VERSION);
	bailAssert(script->version[2] == XS_PATCH_VERSION);
	bailAssert(script->version[3] != -1);
	
	bailIfError(fxLoadModuleJSBAtom(the, fref, &atom));
	bailAssert(atom.atomType == XS_ATOM_SYMBOLS);
	script->symbolsSize = atom.atomSize - sizeof(atom);
	bailIfError(FskMemPtrNew(script->symbolsSize, &script->symbolsBuffer));
	bailIfError(FskFileRead(fref, script->symbolsSize, script->symbolsBuffer, NULL));
	
	bailIfError(fxLoadModuleJSBAtom(the, fref, &atom));
	bailAssert(atom.atomType == XS_ATOM_CODE);
	script->codeSize = atom.atomSize - sizeof(atom);
	bailIfError(FskMemPtrNew(script->codeSize, &script->codeBuffer));
	bailIfError(FskFileRead(fref, script->codeSize, script->codeBuffer, NULL));

bail:
	if (fref)
		FskFileClose(fref);
	if (err) {
		if (script) {
			fxDeleteScript(script);
			script = NULL;
		}
	}
	fxResolveModule(the, moduleID, script, NULL, NULL);
}

FskErr FskMutexNew_(FskMutex *mutex, const char *name, FSK_SYNCHRONIZATION_DEBUG_ARGS)
#endif
{
	FskMutex mtx = NULL;
	FskErr err;

	err = FskMemPtrNewClear(sizeof(FskMutexRecord), (FskMemPtr *)&mtx);
	BAIL_IF_ERR(err);

	err = KplMutexNew((KplMutex*)&mtx->kplMutex);
	BAIL_IF_ERR(err);

#if SUPPORT_INSTRUMENTATION
	mtx->name = FskStrDoCopy_Untracked(name);
	FskInstrumentedItemNew(mtx, mtx->name, &gFskMutexTypeInstrumentation);

#if SUPPORT_SYNCHRONIZATION_DEBUG
	if (FskInstrumentedItemHasListeners(mtx)) {
		FskSynchronizationInstrMsgRecord msg;
		msg.name = name;
		msg.file = file;
		msg.line = line;
		msg.function = function;
		FskInstrumentedItemSendMessage(mtx, kFskSynchronizationInstrMsgMutexNew, &msg);
	}
#endif
#endif

bail:
	if ((err != kFskErrNone) && (mtx != NULL)) {
		KplMutexDispose(mtx->kplMutex);

#if SUPPORT_INSTRUMENTATION
		FskMemPtrDispose_Untracked((void*)mtx->name);
#endif
		FskMemPtrDispose(mtx);
		mtx = NULL;
	}

	*mutex = mtx;

	return err;
}

void refillQueue(FskAudioOut audioOut) {
	void *silence;
	FskAudioOutBlock block;
	androidAudioExt	*ext;

	ext = (androidAudioExt*)audioOut->ext;

	FskAudioNativePrintfDebug("refillQueue");
	if (audioOut->moreCB) {
		SInt32 samplesTarget;
//		SInt32 chunkRequestSize = 8192;
		SInt32 chunkRequestSize = AUDIO_DATA_BUFFER_SIZE;
		samplesTarget = audioOut->sampleRate * audioOut->numChannels;

		if (audioOut->chunkRequestSize)
			chunkRequestSize = audioOut->chunkRequestSize;
		if (audioOut->bufferedSamplesTarget)
			samplesTarget = audioOut->bufferedSamplesTarget;

		while (true) {
			SInt32 samplesNeeded;
			FskErr err;
			samplesNeeded = samplesTarget - (ext->bytesEnqueued / ext->sampleSize);
			//FskAudioNativePrintfDebug("samplesNeeded %d - samplesTarget %d", samplesNeeded, samplesTarget);
			if (samplesNeeded < chunkRequestSize)
				break;
			if (kFskErrNone == (err = (audioOut->moreCB)(audioOut, audioOut->moreRefCon, chunkRequestSize)))
				continue;
#if DONT_GENERATE_SILENCE
			break;
#else
			// make silence
			FskAudioNativePrintfDebug("making silence because more callback returns %d", err);
			FskMemPtrNewClear(chunkRequestSize * 2 * audioOut->numChannels, (FskMemPtr*)&silence);
			if (kFskErrNone != audioOutEnqueue(audioOut, silence, chunkRequestSize * 2 * audioOut->numChannels, NULL, 0, NULL, &block))
				break;
			block->silence = true;
#endif
		}
	}
	FskAudioNativePrintfDebug("refillQueue - DONE");
}

FskErr mraaDigitalNew(FskPinDigital *pin, SInt32 number, const char *name, FskPinsDigitalDirection direction)
{
	FskErr err;
	mraa_gpio_context context;
	mraaDigital md;

	context = mraa_gpio_init(number);
	if (!context) return kFskErrOperationFailed;

	err = FskMemPtrNewClear(sizeof(mraaDigitalRecord), (FskMemPtr *)&md);
	if (err) {
		mraa_gpio_close(context);
		return err;
	}

	md->context = context;

	*pin = (FskPinDigital)md;
	return mraaDigitalSetDirection(*pin, direction);
}

FskErr KplSemaphoreNew(KplSemaphore *sem, UInt32 value)
{
	FskErr err;

	err = FskMemPtrNewClear(sizeof(KplSemaphoreRecord), (FskMemPtr *)sem);
	if (err) goto bail;

	if (sem_init(&(*sem)->hSem, 0, value) != 0) {
		err = kFskErrOperationFailed;
		goto bail;
	}

bail:
	if ((err != kFskErrNone) && (*sem != NULL)) {
		FskMemPtrDispose(*sem);
		*sem = NULL;
	}

	return err;
}

FskNetInterfaceNotifier FskNetInterfaceAddNotifier(FskNetInterfaceChangedCallback callback, void *param, char *debugName)
{
	FskNetInterfaceNotifier notRef = NULL;
	FskThread thread = FskThreadGetCurrent();
	UInt32 nameLen = debugName ? FskStrLen(debugName) + 1 : 0;

	if (kFskErrNone == FskMemPtrNewClear(sizeof(FskNetInterfaceNotifierRec) + nameLen, &notRef)) {
		FskInstrumentedTypePrintfDebug(&gNetInterfaceNotifierTypeInstrumentation, "NetInterfaceNotifier NEW -- %x", notRef);
		notRef->callback = callback;
		notRef->param = param;

		notRef->thread = thread;
		if (nameLen)
			FskMemMove(notRef->name, debugName, nameLen);

		FskListMutexPrepend(interfaceChangeCBList, notRef);
		FskInstrumentedItemNew(notRef, notRef->name, &gNetInterfaceNotifierTypeInstrumentation);
	}
	return notRef;
}

FskErr KprNetworkInterfaceMark(int ip, char *name)
{
	FskErr err = kFskErrNone;
	KprNetworkInterface* address = &gNetworkInterface;
	KprNetworkInterface self;
	while ((self = *address)) {
		if ((self->ip == ip) && !FskStrCompare(self->name, name)) {
			self->flag = 1;
			return err;
		}
        address = &self->next;
	}
	bailIfError(FskMemPtrNewClear(sizeof(KprNetworkInterfaceRecord), address));
	self = *address;
	self->ip = ip;
	self->name = FskStrDoCopy(name);
	bailIfNULL(self->name);
bail:
	return err;
}