/* eslint key-spacing: 0 */
/* eslint quote-props: 0 */

const
	cache = {},
	app = 'application/',
	msOffice = app+'vnd.openxmlformats-officedocument.',
	openDoc = app+'vnd.oasis.opendocument.',
	font = app+'x-font-',
	sizes = ['B', 'KiB', 'MiB', 'GiB', 'TiB'],

	exts = {
	'eml': 'message/rfc822',
	'mime': 'message/rfc822',
	'rtx': 'text/richtext',
	'vcard': 'text/vcard',
	'vcf': 'text/vcard',
	'htm': 'text/html',
	'html': 'text/html',
	'csv': 'text/csv',
	'ics': 'text/calendar',
	'ifb': 'text/calendar',
	'xml': 'text/xml',
	'json': app+'json',
	'p10': app+'pkcs10',
	'p7c': app+'pkcs7-mime',
	'p7m': app+'pkcs7-mime',
	'p7s': app+'pkcs7-signature',
	'torrent': app+'x-bittorrent',

	// scripts
	'js': app+'javascript',
	'pl': 'text/perl',
	'css': 'text/css',
	'asp': 'text/asp',
	'php': app+'x-httpd-php',
	'phtml': app+'x-httpd-php',

	// images
	'jpg': 'image/jpeg',
	'ico': 'image/x-icon',
	'tif': 'image/tiff',
	'svg': 'image/svg+xml',
	'svgz': 'image/svg+xml',

	// archives
	'zip': app+'zip',
	'7z': app+'x-7z-compressed',
	'rar': app+'x-rar-compressed',
	'cab': app+'vnd.ms-cab-compressed',
	'gz': app+'x-gzip',
	'tgz': app+'x-gzip',
	'bz': app+'x-bzip',
	'bz2': app+'x-bzip2',
	'deb': app+'x-debian-package',

	// fonts
	'psf': font+'linux-psf',
	'ttc': font+'ttf',

	// audio
	'mp3': 'audio/mpeg',
	'wav': 'audio/x-wav',
	'mp4a': 'audio/mp4',
	'weba': 'audio/webm',
	'm3u': 'audio/x-mpegurl',

	// video
	'qt': 'video/quicktime',
	'mov': 'video/quicktime',
	'wmv': 'video/windows-media',
	'avi': 'video/x-msvideo',
	'3gp': 'video/3gpp',
	'3g2': 'video/3gpp2',
	'mp4v': 'video/mp4',
	'mpg4': 'video/mp4',
	'ogv': 'video/ogg',
	'm4v': 'video/x-m4v',
	'asf': 'video/x-ms-asf',
	'asx': 'video/x-ms-asf',
	'wm': 'video/x-ms-wm',
	'wmx': 'video/x-ms-wmx',
	'wvx': 'video/x-ms-wvx',
	'movie': 'video/x-sgi-movie',

	// adobe
	'pdf': app+'pdf',
	'psd': 'image/vnd.adobe.photoshop',
	'ai': app+'postscript',
	'eps': app+'postscript',
	'ps': app+'postscript',

	// ms office
	'doc': app+'msword',
	'rtf': app+'rtf',
	'xls': app+'vnd.ms-excel',
	'ppt': app+'vnd.ms-powerpoint',
	'docx': msOffice+'wordprocessingml.document',
	'xlsx': msOffice+'spreadsheetml.sheet',
	'dotx': msOffice+'wordprocessingml.template',
	'pptx': msOffice+'presentationml.presentation',

	// open office
	'odt': openDoc+'text',
	'ods': openDoc+'spreadsheet',
	'odp': openDoc+'presentation'
};

export const FileType = {
	Unknown: 'unknown',
	Text: 'text',
	Html: 'html',
	Code: 'code',
	Eml: 'eml',
	WordText: 'word-text',
	Pdf: 'pdf',
	Image: 'image',
	Audio: 'audio',
	Video: 'video',
	Sheet: 'sheet',
	Presentation: 'presentation',
	Certificate: 'certificate',
	CertificateBin: 'certificate-bin',
	Archive: 'archive'
};

export const File = {
	/**
	 * @param {string} fileName
	 * @returns {string}
	 */
	getExtension: fileName => {
		fileName = fileName.toLowerCase().trim();
		const result = fileName.split('.').pop();
		return result === fileName ? '' : result;
	},

	getContentType: fileName => {
		fileName = fileName.toLowerCase().trim();
		if ('winmail.dat' === fileName) {
			return 'application/ms-tnef';
		}
		let ext = fileName.split('.').pop();
		if (/^(txt|text|def|list|in|ini|log|sql|cfg|conf|asc)$/.test(ext))
			return 'text/plain';
		if (/^(mpe?g|mpe|m1v|m2v)$/.test(ext))
			return 'video/mpeg';
		if (/^aif[cf]?$/.test(ext))
			return 'audio/aiff';
		if (/^(aac|flac|midi|ogg)$/.test(ext))
			return 'audio/'+ext;
		if (/^(h26[134]|jpgv|mp4|webm)$/.test(ext))
			return 'video/'+ext;
		if (/^(otf|pcf|snf|ttf)$/.test(ext))
			return font+ext;
		if (/^(png|jpeg|gif|tiff|webp)$/.test(ext))
			return 'image/'+ext;

		return exts[ext] || app+'octet-stream';
	},

	/**
	 * @param {string} sExt
	 * @param {string} sMimeType
	 * @returns {string}
	 */
	getType: (ext, mimeType) => {
		ext = ext.toLowerCase().trim();
		mimeType = mimeType.toLowerCase().trim().replace('csv/plain', 'text/csv');

		let key = ext + mimeType;
		if (cache[key]) {
			return cache[key];
		}

		let result = FileType.Unknown;
		const mimeTypeParts = mimeType.split('/'),
			type = mimeTypeParts[1].replace('x-','').replace('-compressed',''),
			match = str => type.includes(str);

		switch (true) {
			case 'image' === mimeTypeParts[0] || ['png', 'jpg', 'jpeg', 'gif', 'webp'].includes(ext):
				result = FileType.Image;
				break;
			case 'audio' === mimeTypeParts[0] || ['mp3', 'ogg', 'oga', 'wav'].includes(ext):
				result = FileType.Audio;
				break;
			case 'video' === mimeTypeParts[0] || ['mkv', 'avi'].includes(ext):
				result = FileType.Video;
				break;
			case ['php', 'js', 'css'].includes(ext):
				result = FileType.Code;
				break;
			case 'eml' === ext || ['message/delivery-status', 'message/rfc822'].includes(mimeType):
				result = FileType.Eml;
				break;
			case 'text/html' === mimeType || ['html'].includes(ext):
				result = FileType.Html;
				break;
			case 'text' === mimeTypeParts[0] || ['txt', 'log'].includes(ext):
				result = FileType.Text;
				break;
			case [
					'zip',
					'7z',
					'tar',
					'rar',
					'gzip',
					'bzip',
					'bzip2'
				].includes(type) || ['zip', '7z', 'tar', 'rar', 'gzip', 'bzip', 'bzip2'].includes(ext):
				result = FileType.Archive;
				break;
			case 'pdf' == type || 'pdf' == ext:
				result = FileType.Pdf;
				break;
			case ['application/pgp-signature', 'application/pgp-keys'].includes(mimeType) ||
				['asc', 'pem', 'ppk'].includes(ext):
				result = FileType.Certificate;
				break;
			case ['application/pkcs7-signature'].includes(mimeType) || 'p7s' == ext:
				result = FileType.CertificateBin;
				break;
			case match(msOffice+'.wordprocessingml') || match(openDoc+'.text') || match('vnd.ms-word')
				|| ['rtf', 'msword', 'vnd.msword'].includes(type):
				result = FileType.WordText;
				break;
			case match(msOffice+'.spreadsheetml') || match(openDoc+'.spreadsheet') || match('ms-excel'):
				result = FileType.Sheet;
				break;
			case match(msOffice+'.presentationml') || match(openDoc+'.presentation') || match('ms-powerpoint'):
				result = FileType.Presentation;
				break;
			// no default
		}
		return cache[key] = result;
	},

	/**
	 * @param {string} sFileType
	 * @returns {string}
	 */
	getTypeIconClass: fileType => {
		let result = ['icon-file', ''];
		switch (fileType) {
			case FileType.Text:
			case FileType.Eml:
			case FileType.WordText:
				result[0] += '-text';
				break;
			case FileType.Html:
			case FileType.Code:
				result[0] += '-code';
				break;
			case FileType.Image:
				result[0] += '-image';
				break;
			case FileType.Audio:
				result[0] += '-music';
				break;
			case FileType.Video:
				result[0] += '-movie';
				break;
			case FileType.Archive:
				result[0] += '-zip';
				break;
			case FileType.Certificate:
			case FileType.CertificateBin:
				result[0] += '-certificate';
				break;
			case FileType.Sheet:
				result[0] += '-excel';
				break;
			case FileType.Presentation:
				result[0] += '-chart-graph';
				break;
			case FileType.Pdf:
				result['icon-none', 'pdf'];
				break;
			// no default
		}
		return result;
	},

	getIconClass: (ext, mime) => File.getTypeIconClass(File.getType(ext, mime)),

	/**
	 * @param {string} sFileType
	 * @returns {string}
	 */
	getCombinedIconClass: data => {
		if (Array.isNotEmpty(data)) {
			let icons = data
				.map(item => item ? File.getIconClass(File.getExtension(item[0]), item[1])[0] : '')
				.validUnique();

			return (icons && 1 === icons.length && 'icon-file' !== icons[0])
				 ? icons[0]
				 : 'icon-attachment';
		}

		return '';
	},

	friendlySize: bytes => {
		bytes = parseInt(bytes, 10) || 0;
		let i = Math.floor(Math.log(bytes) / Math.log(1024));
		return (bytes / Math.pow(1024, i)).toFixed(2>i ? 0 : 1) + sizes[i];
	}

};