/*

 *  qlo10k1 - GUI frontend for ld10k1

 *

 *  Copyright (c) 2004 by Peter Zubaj

 *

 *   This program is free software; you can redistribute it and/or modify

 *   it under the terms of the GNU General Public License as published by

 *   the Free Software Foundation; either version 2 of the License, or

 *   (at your option) any later version.

 *

 *   This program is distributed in the hope that it will be useful,

 *   but WITHOUT ANY WARRANTY; without even the implied warranty of

 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *   GNU General Public License for more details.

 *

 *   You should have received a copy of the GNU General Public License

 *   along with this program; if not, write to the Free Software

 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

 *

 */

#include <stdlib.h>

#include "strglobal.h"

#include "strparam.h"

#include "structure.h"

#include "structure_io.h"

#include "structure_link.h"

#include "structure_patch.h"

#include "ld10k1file.h"

StrGlobal::StrGlobal(CardParam *card)

{

	Card = card;

	Card->Structure = this;

	// registers

	Inputs.setAutoDelete(TRUE); // the list owns the objects

	Outputs.setAutoDelete(TRUE);

	FXs.setAutoDelete(TRUE);

	Links.setAutoDelete(TRUE);

	// patches

	Patches.setAutoDelete(TRUE); // the list owns the objects

}

StrGlobal::~StrGlobal(void)

{

	Card = NULL;

}

void StrGlobal::clear(void)

{

	Links.clear();

	Inputs.clear();

	Outputs.clear();

	FXs.clear();

	Patches.clear();

	UsedItems.clear();

}

void StrGlobal::clearFlags(void)

{

	StrFX *fx = NULL;

	for(fx = FXs.first(); fx; fx = FXs.next())

        {

		fx->setFlagUsed(false);

		fx->setFlagNew(false);

		fx->setFlagChanged(false);

	}

	StrInput *in = NULL;

	for(in = Inputs.first(); in; in = Inputs.next())

        {

		in->setFlagUsed(false);

		in->setFlagNew(false);

		in->setFlagChanged(false);

	}

	StrOutput *out = NULL;

	for(out = Outputs.first(); out; out = Outputs.next())

        {

		out->setFlagUsed(false);

		out->setFlagNew(false);

		out->setFlagChanged(false);

	}

	StrPatch *p = NULL;

	for(p = Patches.first(); p; p = Patches.next())

        {

		p->setFlagUsed(false);

		p->setFlagNew(false);

		p->setFlagChanged(false);

	}

	StrLink *l = NULL;

	for(l = Links.first(); l; l = Links.next())

        {

		l->setFlagUsed(false);

		l->setFlagNew(false);

		l->setFlagChanged(false);

	}

}

int StrGlobal::loadFromLD(void)

{

	clearFlags();

	// load registers

	int cnt;

	int err = 0;

	int i;

	QString ioname;

	// FXs

	if ((err = Card->getFXCount(&cnt)) < 0)

		return err;

	for (i = 0; i < cnt; i++)

	{

		if ((err = Card->getFX(i, ioname)) < 0)

			return err;

		StrFX *fx = findFXByNum(i);

		if (fx)

		{

			if (fx->name() != ioname)

			{

				fx->setName(ioname);

				fx->setFlagChanged(true);

			}

			// Don't make unconnected IO/FX disappear.

			fx->setFlagUsed(true);

		}

		else

		{

			fx = new StrFX(i, ioname);

			fx->setFlagNew(true);

			FXs.append(fx);

		}

	}

	if ((err = Card->getInputCount(&cnt)) < 0)

		return err;

	for (i = 0; i < cnt; i++)

	{

		if ((err = Card->getInput(i, ioname)) < 0)

			return err;

		StrInput *in = findInputByNum(i);

		if (in)

		{

			if (in->name() != ioname)

			{

				in->setName(ioname);

				in->setFlagChanged(true);

			}

			in->setFlagUsed(true);

		}

		else

		{

			in = new StrInput(i, ioname);

			in->setFlagNew(true);

			Inputs.append(in);

		}

	}

	if ((err = Card->getOutputCount(&cnt)) < 0)

		return err;

	for (i = 0; i < cnt; i++)

	{

		if ((err = Card->getOutput(i, ioname)) < 0)

			return err;

		StrOutput *out = findOutputByNum(i);

		if (out)

		{

			if (out->name() != ioname)

			{

				out->setName(ioname);

				out->setFlagChanged(true);

			}

			out->setFlagUsed(true);

		}

		else

		{

			out = new StrOutput(i, ioname);

			out->setFlagNew(true);

			Outputs.append(out);

		}

	}

	// load patches and patch registers

	CardParamPatchInfo **pi;

	if ((err = Card->getPatchesInfo(&pi, &cnt)) < 0)

		return err;

	// copy registers to internal structure

	for (i = 0; i < cnt; i++)

	{

		StrPatch *patch = NULL;

		if ((err = actualizePatch(pi[i]->id, pi[i]->patch_num, pi[i]->patch_name, &patch)) < 0)

		{

			for (i = 0; i < cnt; i++)

				delete pi[i];

			delete pi;

			return err;

		}

		patch->setOrder(i);

	}

	for (i = 0; i < cnt; i++)

		delete pi[i];

	delete pi;

	int *ld_tmplids = NULL;

	if ((err = Card->getPointsInfo(&ld_tmplids, &cnt)) < 0)

		return err;

	for (i = 0; i < cnt; i++)

	{

		StrLink *link = NULL;

		if ((err = actualizeLink(ld_tmplids[i], &link)) < 0)

		{

			free(ld_tmplids);

			return err;

		}

	}

	free(ld_tmplids);

	// copy used items

	StrPatch *patch;

	UsedItems.clear();

	for(patch = Patches.first(); patch; patch = Patches.next() )

	{

		if (patch->flagUsed())

			UsedItems.append(patch);

	}

	// remove unused

	for(patch = Patches.last(); patch; patch = Patches.prev() )

	{

		if (!patch->flagUsed())

			Patches.remove(patch);

	}

	QPtrListIterator <StrInput> itin(Inputs);

	StrInput *in;

	while ((in = itin.current()) != 0 ) {

		++itin;

		if (in->flagUsed())

			UsedItems.append(in);

		else

			Inputs.remove(in);

	}

	QPtrListIterator <StrOutput> itout(Outputs);

	StrOutput *out;

	while ((out = itout.current()) != 0 ) {

		++itout;

		if (out->flagUsed())

			UsedItems.append(out);

		else

			Outputs.remove(out);

	}

	QPtrListIterator <StrFX> itfx(FXs);

	StrFX *fx;

	while ((fx = itfx.current()) != 0 ) {

		++itfx;

		if (fx->flagUsed())

			UsedItems.append(fx);

		else

			FXs.remove(fx);

	}

	QPtrListIterator <StrLink> itlnk(Links);

	StrLink *lnk;

	while ((lnk = itlnk.current()) != 0 ) {

		++itlnk;

		if (lnk->flagUsed())

			UsedItems.append(lnk);

		else

			Links.remove(lnk);

	}

	updatePatchesOrder();

	AutoArange(&UsedItems);

	QPtrListIterator <StrLink> itlnk1(Links);

	while ((lnk = itlnk1.current()) != 0 ) {

		++itlnk1;

		lnk->calcSize();

	}

	return 0;

}

int StrGlobal::getPio(int pnum, bool out, int idx, QString &name)

{

	int err;

	if (out)

		err = Card->getPOutput(pnum, idx, name);

	else

		err = Card->getPInput(pnum, idx, name);

	return err;

}

int StrGlobal::actualizePatch(int pid, int pnum, QString pname, StrPatch **out)

{

	QString ioname;

	int z, j;

	int err;

	int cnt1[2];

	if ((err = Card->getPInputCount(pnum, &(cnt1[0]))) < 0)

		return err;

	if ((err = Card->getPOutputCount(pnum, &(cnt1[1]))) < 0)

		return err;

	StrPatch *patch = findPatchById(pid);

	if (patch)

	{

		// check changes

		if (patch->name() != pname)

		{

			patch->setName(pname);

			patch->setFlagChanged(true);

		}

		for (z = 0; z < 2; z++)

		{

			for (j = 0; j < cnt1[z]; j++)

			{

				if ((err = getPio(pnum, z, j, ioname)) < 0)

					return err;

				RSItemIO *io = patch->getIO(z, j);

				if (io->getDesc() != ioname)

				{

					io->setDesc(ioname);

					patch->setFlagChanged(true);

				}

			}

		}

	}

	else

	{

		patch = new StrPatch(pnum, pid, pname);

		Patches.append(patch);

		for (z = 0; z < 2; z++)

		{

			for (j = 0; j < cnt1[z]; j++)

			{

				if ((err = getPio(pnum, z, j, ioname)) < 0)

					return err;

				RSItemIO *io = new RSItemIO(patch, z, j, ioname);

				patch->setIO(z, j, io);

			}

		}

		patch->setFlagNew(true);

	}

	patch->setFlagUsed(true);

	*out = patch;

	return 0;

}

StrPatch *StrGlobal::findPatchByNum(int num)

{

	StrPatch *patch;

	for(patch = Patches.first(); patch; patch = Patches.next() )

	{

		if (patch->num() == num)

			return patch;

	}

	return NULL;

}

StrPatch *StrGlobal::findPatchById(int id)

{

	StrPatch *patch;

	for(patch = Patches.first(); patch; patch = Patches.next() )

	{

		if (patch->id() == id)

			return patch;

	}

	return NULL;

}

StrFX *StrGlobal::findFXByNum(int num)

{

	StrFX *fx;

	for(fx = FXs.first(); fx; fx = FXs.next() )

	{

		if (fx->num() == num)

			return fx;

	}

	return NULL;

}

StrInput *StrGlobal::findInputByNum(int num)

{

	StrInput *in;

	for(in = Inputs.first(); in; in = Inputs.next() )

	{

		if (in->num() == num)

			return in;

	}

	return NULL;

}

StrOutput *StrGlobal::findOutputByNum(int num)

{

	StrOutput *out;

	for(out = Outputs.first(); out; out = Outputs.next() )

	{

		if (out->num() == num)

			return out;

	}

	return NULL;

}

StrLink *StrGlobal::findLinkById(int id)

{

	StrLink *l;

	for(l = Links.first(); l; l = Links.next() )

	{

		if (l->id() == id)

			return l;

	}

	return NULL;

}

int StrGlobal::conAdd(bool multi, bool simple, RSItemIO *from_io, RSItemIO *to_io, int *id)

{

	int ftype = 0;

	int ttype = 0;

	int type = 0;

	int fp = 0;

	int tp = 0;

	int p = 0;

	int fio = 0;

	int tio = 0;

	int io = 0;

	RSItemIO *tmp;

	RSItemBaseWithType *owner;

	for (int i = 0; i < 2; i++)

	{

		if (!i)

			tmp = from_io;

		else

			tmp = to_io;

		owner = (RSItemBaseWithType *)tmp->getOwner();

		p = -1;

		io = -1;

		switch (owner->type())

		{

			case RSItemBaseWithType::In:

				type = CON_IO_IN;

				io = ((StrInput *)owner)->num();

				break;

			case RSItemBaseWithType::Out:

				type = CON_IO_OUT;

				io = ((StrOutput *)owner)->num();

				break;

			case RSItemBaseWithType::FX:

				type = CON_IO_FX;

				io = ((StrFX *)owner)->num();

				break;

			case RSItemBaseWithType::Patch:

				if (!tmp->isOutput())

					type = CON_IO_PIN;

				else

					type = CON_IO_POUT;

				io = tmp->getIdx();

				p = ((StrPatch *)owner)->num();

				break;

			default:

				break;

		}

		if (!i)

		{

			ftype = type;

			fio = io;

			fp = p;

		}

		else

		{

			ttype = type;

			tio = io;

			tp = p;

		}

	}

	return Card->conAdd(multi, simple, ftype, fp, fio, ttype, tp, tio, id);

	// FIXME - uprava strglobal - urobene inde

}

int StrGlobal::conDel(RSItemIO *from_io, int *id)

{

	int io, p;

	int type = 0;

	RSItemBaseWithType *owner;

	owner = (RSItemBaseWithType *)from_io->getOwner();

	p = -1;

	io = -1;

	switch (owner->type())

	{

		// only patch valid

		case RSItemBaseWithType::Patch:

			if (!from_io->isOutput())

				type = CON_IO_PIN;

			else

				type = CON_IO_POUT;

			io = from_io->getIdx();

			p = ((StrPatch *)owner)->num();

			break;

		default:

			break;

	}

	return Card->conDel(type, p, io, id);

}

int StrGlobal::load(LD10k1File *ld10k1file, StrPatch *before, StrPatch **loaded)

{

	int bef = -1;

	int loade, loade_id;

	int retval;

	if (before)

		bef = before->num();

	if ((retval = Card->load(ld10k1file, bef, &loade, &loade_id)) < 0)

		return retval;

	StrPatch *p = NULL;

	if ((retval = actualizePatch(loade_id, loade, ld10k1file->getPatchName(), &p)) < 0)

		return retval;

	UsedItems.append(p);

	updatePatchesOrder();

	AutoArange(&UsedItems);

	*loaded = p;

	return retval;

}

int StrGlobal::unload(StrPatch *p)

{

	int retval;

	if ((retval = Card->unload(p->num())) < 0)

		return retval;

	// FIXME - odmaz aj prepojenia

	UsedItems.remove(p);

	Patches.remove(p);

	updatePatchesOrder();

	return retval;

}

int StrGlobal::clearDSP(void)

{

	int retval;

	if ((retval = Card->clearDSP()) < 0)

		return retval;

	clear();

	return 0;

}

void StrGlobal::destroyLink(StrLink *l)

{

	UsedItems.remove(l);

	l->disconnectAll();

	// delete not needed - autodelete

	Links.remove(l);

}

int StrGlobal::disconnectFromLink(RSItemIO *io)

{

	StrLink *link = io->getConnectedTo();

	if (link)

	{

		int idx = link->findRoute(io);

		int conn_id;

		int err;

		if((err = conDel(io, &conn_id)) < 0)

			return err;

		link->setRoutePoint(idx, NULL);

		if (conn_id < 0 || !link->isValid())

		{

			destroyLink(link);

			return 0;

		}

		link->calcSize();

	}

	return 0;

}

int StrGlobal::actualizeLink(int id, StrLink **out)

{

	int err;

	CardParamPointInfo point;

	err = Card->getPointInfo(id, &point);	

	if (err == LD10K1_ERR_UNKNOWN_POINT)

	{

		// FIXME - probably not exists - remove

		StrLink *delLink = findLinkById(id);

		if (delLink)

			destroyLink(delLink);

		*out = NULL;

		return 0;

	}

	if (err < 0)

		return err;

	RSItemIO *firstItem = NULL;

	StrLink::LinkType newType = StrLink::LinkFX;

	switch(point.type)

	{

		case CON_IO_FX:

			newType = StrLink::LinkFX;

			{

				StrFX *ft = findFXByNum(point.io_idx);

				if (ft)

					firstItem = ft->getIO(true, 0);

			}

			break;

		case CON_IO_IN:

			newType = StrLink::LinkIn;

			{

				StrInput *in = findInputByNum(point.io_idx);

				if (in)

					firstItem = in->getIO(true, 0);

			}

			break;

		case CON_IO_OUT:

			newType = StrLink::LinkOut;

			{

				StrOutput *out = findOutputByNum(point.io_idx);

				if (out)

					firstItem = out->getIO(false, 0);

			}

			break;

		case CON_IO_NORMAL:

			newType = StrLink::LinkNormal;

			break;

	}

	StrLink *link = findLinkById(id);

	if (link)

	{

		bool actualized[POINTINFO_MAX_CONN_PER_POINT];

		RSItemIO *newIOs[POINTINFO_MAX_CONN_PER_POINT];

		unsigned int j;

		unsigned int niosc = 0;

		for (j = 0; j < POINTINFO_MAX_CONN_PER_POINT; j++)

			actualized[j] = false;

		int r = 0;

		if (firstItem)

		{

			actualized[r] = true;

			((RSItemBaseWithType *)firstItem->getOwner())->setFlagUsed(true);

			r++;

		}

		// actualize current

		for (j = 0; j < point.conn_count; j++)

		{

			RSItemIO *io = findPatchIO(point.io_type[j], point.patch[j], point.io[j]);

			((RSItemBaseWithType *)io->getOwner())->setFlagUsed(true);

			// find io

			int rf = link->findRoute(io);

			if (rf >= 0)

			{

				actualized[rf] = true;

				link->setRoutePoint(rf, io);	

			}

			else

			{

				newIOs[niosc++] = io;

			}		

		}

		// delete old

		for (j = 0; j < POINTINFO_MAX_CONN_PER_POINT; j++)

		{

			if (!actualized[j])

			{

				link->setRoutePoint(j, NULL);

				link->clearRoutesPoints(j);

			}

		}

		// add new

		int l = 0;

		for (j = 0; j < niosc; j++)

		{

			for (; l < POINTINFO_MAX_CONN_PER_POINT; l++)

			{

				if (!link->getRoutePoint(l))

				{

					link->setRoutePoint(l, newIOs[j]);

					break;

				}

			}

		}

		link->setFlagChanged(true);

	}

	else

	{

		link = new StrLink(id, newType);

		int r = 0;

		if (firstItem)

		{

			link->setRoutePoint(r++, firstItem);

			((RSItemBaseWithType *)firstItem->getOwner())->setFlagUsed(true);

		}

		unsigned int j = 0;

		for (j = 0; j < point.conn_count; j++)

		{

			RSItemIO *io = findPatchIO(point.io_type[j], point.patch[j], point.io[j]);

			((RSItemBaseWithType *)io->getOwner())->setFlagUsed(true);

			link->setRoutePoint(r++, io);

		}

		link->setFlagNew(true);

		Links.append(link);

		UsedItems.append(link);

	}

	link->setFlagUsed(true);

	*out = link;

	return 0;

}

void StrGlobal::updatePatchesOrder(void)

{

	CardParamPatchInfo **pi;

	int i, cnt;

	int err;

	if ((err = Card->getPatchesInfo(&pi, &cnt)) < 0)

		return;

	for (i = 0; i < cnt; i++)

	{

		StrPatch *p = findPatchById(pi[i]->id);

		if (p)

			p->setOrder(i);

	}

	for (i = 0; i < cnt; i++)

		delete pi[i];

	delete pi;

}

RSItemIO *StrGlobal::findPatchIO(bool out, int pid, int ionum)

{

	if (pid < 0 || ionum < 0)

		return NULL;

	StrPatch *p = findPatchById(pid);

	if (!p)

		return NULL;

	return p->getIO(out, ionum);

}

int StrGlobal::deleteOneLink(StrLink *l)

{

	int err;

	for (int i = 0; i < l->getMaxRoute(); i++)

	{

		RSItemIO *io = l->getRoutePoint(i);

		if (io)

		{

			RSItemBaseWithType *owner = (RSItemBaseWithType *)io->getOwner();

			if (owner->type() == RSItemBaseWithType::Patch)

			{

				// only patch can be disconnected

				int conn_id;

				if((err = conDel(io, &conn_id)) < 0)

					return err;

				if (conn_id < 0)

				{

					destroyLink(l);

					return 0;

				}

			}

		}

	}

	return 0;

}

int StrGlobal::deleteOneFX(StrFX *fx)

{

	int err;

	RSItemIO *io = fx->getIO(true, 0);

	if (io)

	{

		StrLink *l = io->getConnectedTo();

		if (l)

		{

			if ((err = deleteOneLink(l)) < 0)

				return err;

		}

	}

	UsedItems.remove(fx);

	// delete not needed - autodelete

	FXs.remove(fx);

	return 0;

}

int StrGlobal::deleteOneIn(StrInput *in)

{

	int err;

	RSItemIO *io = in->getIO(true, 0);

	if (io)

	{

		StrLink *l = io->getConnectedTo();

		if (l)

		{

			if ((err = deleteOneLink(l)) < 0)