/*
 * FreeRTOS+FAT build 191128 - Note:  FreeRTOS+FAT is still in the lab!
 * Copyright (C) 2018 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
 * Authors include James Walmsley, Hein Tibosch and Richard Barry
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * https://www.FreeRTOS.org
 *
 */

#include <stdio.h>
#include <string.h>

/* FreeRTOS includes. */
#include "FreeRTOS.h"
#include "task.h"
#include "portable.h"

#include "ff_headers.h"
#include "ff_sys.h"

#ifndef ARRAY_SIZE
#	define	ARRAY_SIZE(x)	( int )( sizeof( x ) / sizeof( x )[ 0 ] )
#endif

/*
 * Define a collection of 'file systems' as a simple array
 */
typedef struct xSYSTEM
{
	FF_SubSystem_t xSystems[ ffconfigMAX_FILE_SYS ];
	volatile BaseType_t xFileSystemCount;
} ff_sys_t;


static ff_sys_t file_systems;
static const char rootDir[] = "/";

int FF_FS_Count( void )
{
	return ( int )file_systems.xFileSystemCount;
}
/*-----------------------------------------------------------*/

void FF_FS_Init( void )
{
	memset( &file_systems, '\0', sizeof( file_systems ) );

	/* There is always a root file system, even if it doesn't have a
	IO manager. */
	file_systems.xFileSystemCount = ( BaseType_t ) 1;
	/* Set to "/", second byte is already zero. */
	file_systems.xSystems[ 0 ].pcPath[ 0 ] = ( char ) '/';

	file_systems.xSystems[ 0 ].xPathlen = 1;
}
/*-----------------------------------------------------------*/

int FF_FS_Add( const char *pcPath, FF_Disk_t *pxDisk )
{
int iReturn = pdFALSE;

	configASSERT( pxDisk );

	if( *pcPath != ( char ) '/' )
	{
		FF_PRINTF( "FF_FS_Add: Need a \"/\": '%s'\n", pcPath );
	}
	else
	{
	BaseType_t xUseIndex = -1;
	size_t uxPathLength = strlen( pcPath );

		vTaskSuspendAll();
		{
			if( file_systems.xFileSystemCount == ( BaseType_t ) 0 )
			{
				FF_FS_Init();
			}

			if( uxPathLength == ( size_t ) 1u )
			{
				/* This is the "/" path
				 * and will always be put at index 0 */
				xUseIndex = ( BaseType_t ) 0;
			}
			else
			{
			BaseType_t xIndex, xFreeIndex = -1;
			FF_SubSystem_t *pxSubSystem = file_systems.xSystems + 1;	/* Skip the root entry */

				for( xIndex = ( BaseType_t ) 1; xIndex < file_systems.xFileSystemCount; xIndex++, pxSubSystem++ )
				{
					if( ( pxSubSystem->xPathlen == ( BaseType_t )uxPathLength ) &&
						( memcmp( pxSubSystem->pcPath, pcPath, uxPathLength ) == 0 ) )
					{
						/* A system is updated with a new handler. */
						xUseIndex = xIndex;
						break;
					}
					if( ( pxSubSystem->pxManager == NULL ) && ( xFreeIndex < 0 ) )
					{
						/* Remember the first free slot. */
						xFreeIndex = xIndex;
					}
				}
				if( xUseIndex < ( BaseType_t ) 0 )
				{
					if( xFreeIndex >= ( BaseType_t ) 0 )
					{
						/* Use the first free slot. */
						xUseIndex = xFreeIndex;
					}
					else if( file_systems.xFileSystemCount < ARRAY_SIZE( file_systems.xSystems ) )
					{
						/* Fill a new entry. */
						xUseIndex = file_systems.xFileSystemCount++;
					}
				}
			} /* uxPathLength != 1 */
			if( xUseIndex >= ( BaseType_t ) 0 )
			{
				iReturn = pdTRUE;
				strncpy( file_systems.xSystems[ xUseIndex ].pcPath, pcPath, sizeof( file_systems.xSystems[ xUseIndex ].pcPath ) );
				file_systems.xSystems[ xUseIndex ].xPathlen = uxPathLength;
				file_systems.xSystems[ xUseIndex ].pxManager = pxDisk->pxIOManager;
			}
		}
		xTaskResumeAll( );
		if( iReturn == pdFALSE )
		{
			FF_PRINTF( "FF_FS_Add: Table full '%s' (max = %d)\n", pcPath, (int)ARRAY_SIZE( file_systems.xSystems ) );
		}
	}

	return iReturn;
}
/*-----------------------------------------------------------*/

void FF_FS_Remove( const char *pcPath )
{
BaseType_t xUseIndex, xIndex;
size_t uxPathLength;

	if( pcPath[ 0 ] == ( char ) '/' )
	{
		xUseIndex = -1;
		uxPathLength = strlen( pcPath );
		/* Is it the "/" path ? */
		if( uxPathLength == ( size_t ) 1u )
		{
			xUseIndex = 0;
		}
		else
		{
			FF_SubSystem_t *pxSubSystem = file_systems.xSystems + 1;
			for( xIndex = 1; xIndex < file_systems.xFileSystemCount; xIndex++, pxSubSystem++ )
			{
				if( ( pxSubSystem->xPathlen == ( BaseType_t ) uxPathLength ) &&
					( memcmp( pxSubSystem->pcPath, pcPath, uxPathLength ) == 0 ) )
				{
					xUseIndex = xIndex;
					break;
				}
			}
		}
		if( xUseIndex >= 0 )
		{
			vTaskSuspendAll();
			{
				file_systems.xSystems[ xUseIndex ].pxManager = NULL;
				file_systems.xSystems[ xUseIndex ].xPathlen = ( BaseType_t )0;
				for( xIndex = file_systems.xFileSystemCount - 1; xIndex > 0; xIndex-- )
				{
					if( file_systems.xSystems[ xIndex ].pxManager != NULL )
					{
						/* The slot at 'xIndex' is still in use. */
						break;
					}
				}
				file_systems.xFileSystemCount = xIndex + 1;
			}
			xTaskResumeAll( );
		}
	}
}
/*-----------------------------------------------------------*/

int FF_FS_Find( const char *pcPath, FF_DirHandler_t *pxHandler )
{
FF_SubSystem_t *pxSubSystem;
size_t uxPathLength;
BaseType_t xUseIndex;
int iReturn;

	pxSubSystem = file_systems.xSystems + 1;
	uxPathLength = strlen( pcPath );

	memset( pxHandler, '\0', sizeof( *pxHandler ) );
	for( xUseIndex = 1; xUseIndex < file_systems.xFileSystemCount; xUseIndex++, pxSubSystem++ )
	{
		if( ( uxPathLength >= ( size_t ) pxSubSystem->xPathlen ) &&
			( memcmp( pxSubSystem->pcPath, pcPath, ( size_t ) pxSubSystem->xPathlen ) == 0 ) &&
			( ( pcPath[ pxSubSystem->xPathlen ] == '\0' ) || ( pcPath[ pxSubSystem->xPathlen ] == '/') ) )	/* System "/ram" should not match with "/ramc/etc". */
		{
			if( pcPath[ pxSubSystem->xPathlen ] == '\0')
			{
				pxHandler->pcPath = rootDir;
			}
			else
			{
				pxHandler->pcPath = pcPath + pxSubSystem->xPathlen;
			}

			pxHandler->pxManager = pxSubSystem->pxManager;
			break;
		}
	}

	if( xUseIndex == file_systems.xFileSystemCount )
	{
		pxHandler->pcPath = pcPath;
		pxHandler->pxManager = file_systems.xSystems[ 0 ].pxManager;
	}

	if( FF_Mounted( pxHandler->pxManager ) )
	{
		iReturn = pdTRUE;
	}
	else
	{
		iReturn = pdFALSE;
	}

	return iReturn;
}
/*-----------------------------------------------------------*/

int FF_FS_Get( int xIndex, FF_SubSystem_t *pxSystem )
{
int iReturn;

	/* Get a copy of a fs info. */
	if( ( xIndex < 0 ) || ( xIndex >= file_systems.xFileSystemCount ) )
	{
		iReturn = pdFALSE;
	}
	else
	{
		/* Note: it will copy the contents of 'FF_SubSystem_t'. */
		*pxSystem = file_systems.xSystems[ xIndex ];
		iReturn = pdTRUE;
	}

	return iReturn;
}
/*-----------------------------------------------------------*/