/*  GnuBarcode.cpp
 *
 *  Copyright (C) 2017  Jim Evins <evins@snaught.com>
 *
 *  This file is part of gLabels-qt.
 *
 *  gLabels-qt 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 3 of the License, or
 *  (at your option) any later version.
 *
 *  gLabels-qt 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 gLabels-qt.  If not, see <http://www.gnu.org/licenses/>.
 */

#if HAVE_GNU_BARCODE

#include "GnuBarcode.h"

#include <QtDebug>
#include <barcode.h>
#include <cctype>


namespace
{
	const double INK_BLEED = 0.1; /* Shrink bars to account for ink bleed. */
	const double FONT_SCALE = 0.75; /* Shrink font slightly, otherwise too crowded. */
}


namespace glabels
{
	namespace barcode
	{
		namespace GnuBarcode
		{

			bool Base::isAscii( const std::string& data ) const
			{
				for (char c : data)
				{
					if ( (c & 0x80) != 0 )
					{
						return false;
					}
				}

				return true;			
			}
		
			
			bool Base::isNumericLengthValid( const std::string& data,
			                                 unsigned int       nMin,
			                                 unsigned int       nMax ) const
			{
				unsigned int n = 0;

				for (char c : data)
				{
					if ( isdigit(c) )
					{
						n++;
					}
				}

				return (n >= nMin) && (n <= nMax);
			}
		

			bool Base::isNumericLength1Valid( const std::string& data,
			                                  unsigned int       nMin,
			                                  unsigned int       nMax ) const
			{
				unsigned int n = 0;

				for ( unsigned int i = 0; !isspace(data[i]) && (i < data.size()); i++ )
				{
					if ( isdigit(data[i]) )
					{
						n++;
					}
					else if ( !isspace(data[i]) )
					{
						return false;
					}
				}

				return (n >= nMin) && (n <= nMax);
			}
		

			bool Base::isNumericLength2Valid( const std::string& data,
			                                  unsigned int       nMin,
			                                  unsigned int       nMax ) const
			{
				unsigned int i;
				unsigned int n = 0;

				for ( i = 0; !isspace(data[i]) && (i < data.size()); i++ )
				{
					/* Skip over 1st string */
				}

				for ( i++ /* skip space */ ; i < data.size(); i++ )
				{
					if ( isdigit(data[i]) )
					{
						n++;
					}
					else
					{
						return false;
					}
				}

				return (n >= nMin) && (n <= nMax);
			}
		
			
			void Base::vectorize( const std::string& encodedData,
			                      const std::string& displayText,
			                      const std::string& cookedData,
			                      double&            w,
			                      double&            h )
			{
				/*
				 * First encode using GNU Barcode library.
				 */
				Barcode_Item* bci = Barcode_Create( (char*)cookedData.c_str() );

				bci->scalef = 0;
				bci->width  = (int)w;
				bci->height = (int)h;

				bci->flags = flags;
				if ( !showText() )
				{
					bci->flags |= BARCODE_NO_ASCII;
				}
				if ( !checksum() )
				{
					bci->flags |= BARCODE_NO_CHECKSUM;
				}

				Barcode_Encode( bci, flags );

				if ( (bci->partial == nullptr) || (bci->textinfo == nullptr) )
				{
					Barcode_Delete( bci );
					setIsDataValid( false );
					return;
				}


				/*
				 * Now do the actual vectorization.
				 *
				 * This code is based on the postscript renderer (ps.c) from the GNU barcode library:
				 *
				 *     Copyright (C) 1999 Alessaandro Rubini (rubini@gnu.org)
				 *     Copyright (C) 1999 Prosa Srl. (prosa@prosa.it)
				 */
				if (bci->width > (2*bci->margin))
				{
					bci->width -= 2*bci->margin;
				}
				if (bci->height > (2*bci->margin))
				{
					bci->height -= 2*bci->margin;
				}

				/* First calculate barlen */
				int barlen = bci->partial[0] - '0';
				for ( int i = 1; bci->partial[i] != 0; i++ )
				{
					if ( isdigit(bci->partial[i]) )
					{
						barlen += bci->partial[i] - '0';
					}
					else
					{
						if ( (bci->partial[i] != '+') && (bci->partial[i] != '-') )
						{
							barlen += bci->partial[i] - 'a' + 1;
						}
					}
				}

				/* The scale factor depends on bar length */
				double scalef = 1;
				if ( bci->scalef == 0 )
				{
					if ( bci->width == 0 )
					{
						bci->width = barlen; /* default */
					}
					scalef = bci->scalef = (double)bci->width / (double)barlen;
					if ( scalef < 0.5 )
					{
						scalef = 0.5;
					}
				}

				/* The width defaults to "just enough" */
				bci->width = (int)( barlen * scalef + 1 );

				/* But it can be too small, in this case enlarge and center the area */
				if ( bci->width < (int)(barlen * scalef) )
				{
					auto wid = int( barlen * scalef + 1);
					bci->xoff -= (wid - bci->width)/2 ;
					bci->width = wid;
					/* Can't extend too far on the left */
					if (bci->xoff < 0)
					{
						bci->width += -bci->xoff;
						bci->xoff = 0;
					}
				}

				/* The height defaults to 80 points (rescaled) */
				if ( bci->height == 0 )
				{
					bci->height = (int)( 80 * scalef );
				}

				/* If too small (5 + text), reduce the scale factor and center */
				int i = 5 + 10 * ( ((bci->flags & BARCODE_NO_ASCII)==0) ? 1 : 0 );
				if ( bci->height < (int)(i * scalef) )
				{
					bci->height = (int)( i * scalef );
				}

				/* Now traverse the code string and create a list of lines */
				char mode = '-'; /* text below bars */
				double x = bci->margin + (bci->partial[0] - '0') * scalef;
				i = 1;
				for ( int ip = 1; bci->partial[ip] != 0; ip++, i++)
				{
					/* special cases: '+' and '-' */
					if ( bci->partial[ip] == '+' || bci->partial[ip] == '-' )
					{
						mode = bci->partial[ip];        /* don't count it */
						i++;
						continue;
					}
					/* j is the width of this bar/space */
					int j;
					if ( isdigit(bci->partial[ip]) )
					{
						j = bci->partial[ip] - '0';
					}
					else
					{
						j = bci->partial[ip] - 'a' + 1;
					}
					if ( (i % 2) != 0 )
					{
						/* bar */
						double x0 = x;
						double y0 = bci->margin;
						double yr = bci->height;
						if ( (bci->flags & BARCODE_NO_ASCII) == 0 )
						{
							/* leave space for text */
							if (mode == '-')
							{
								/* text below bars: 10 or 5 points */
								yr -= (isdigit(bci->partial[ip]) ? 10 : 5) * scalef;
							}
							else
							{
								/* '+' */
								/* above bars: 10 or 0 from bottom,
								   and 10 from top */
								y0 += 10 * scalef;
								yr -= (isdigit(bci->partial[ip]) ? 20 : 10) * scalef;
							}
						}
						addBox( x0, y0, (j * scalef) - INK_BLEED, yr );
					}
					x += j * scalef;

				}

				/* Now the text */
				mode = '-';                /* reinstantiate default */
				if ( (bci->flags & BARCODE_NO_ASCII) == 0 )
				{
					int len = strlen( bci->textinfo );
					for ( int i = 0; i < len; i++ )
					{
						if ( bci->textinfo[i] == ' ' )
						{
							continue;
						}
						if ( (bci->textinfo[i] == '+') || (bci->textinfo[i] == '-') )
						{
							mode = bci->textinfo[i];
							continue;
						}
						double f1, f2;
						char   c;
						if ( sscanf( &bci->textinfo[i], "%lf:%lf:%c", &f1, &f2, &c) != 3 )
						{
							qDebug() << "Impossible data:" << QString(&bci->textinfo[i]);
							continue;
						}
						f2 *= FONT_SCALE;
						double x0 = f1*scalef + bci->margin + 0.4*f2*scalef;
						double y0;
						if (mode == '-')
						{
							y0 = bci->margin + bci->height - 8*scalef + 0.75*f2*scalef;
						}
						else
						{
							y0 = bci->margin + 0.75*f2*scalef;
						}
						addText( x0, y0, f2*scalef, QString(c).toStdString() );

						/* skip past the substring we just read. */
						while ( (bci->textinfo[i] != ' ') && (bci->textinfo[i] != 0) )
						{
							i++;
						}
					}
				}

				/* Fill in other info */
				w = bci->width  + 2.0*bci->margin;
				h = bci->height + 2.0*bci->margin;

				/* Cleanup */
				Barcode_Delete( bci );
			}


			//////////////////////////////////////////////////////
			// EAN Barcode (Any)
			//////////////////////////////////////////////////////
			glbarcode::Barcode* Ean::create()
			{
				return new Ean();
			}

		
			bool Ean::validate( const std::string& rawData )
			{
				return (      isNumericLengthValid(  rawData,  7,  8 )
				              ||   isNumericLengthValid(  rawData, 12, 13 )
				              || ( isNumericLength1Valid( rawData,  7,  8 ) && isNumericLength2Valid( rawData, 2, 2 ) )
				              || ( isNumericLength1Valid( rawData,  7,  8 ) && isNumericLength2Valid( rawData, 5, 5 ) )
				              || ( isNumericLength1Valid( rawData, 12, 13 ) && isNumericLength2Valid( rawData, 2, 2 ) )
				              || ( isNumericLength1Valid( rawData, 12, 13 ) && isNumericLength2Valid( rawData, 5, 5 ) ) );
			}

		
			std::string Ean::encode( const std::string& cookedData )
			{
				flags = BARCODE_EAN;
				return ""; // Actual encoding is done in vectorize
			}
		

			//////////////////////////////////////////////////////
			// EAN-8 Barcode
			//////////////////////////////////////////////////////
			glbarcode::Barcode* Ean8::create()
			{
				return new Ean8();
			}

		
			bool Ean8::validate( const std::string& rawData )
			{
				return isNumericLengthValid(  rawData,  7,  8 );
			}

		
			std::string Ean8::encode( const std::string& cookedData )
			{
				flags = BARCODE_EAN;
				return ""; // Actual encoding is done in vectorize
			}
		

			//////////////////////////////////////////////////////
			// EAN-8+2 Barcode
			//////////////////////////////////////////////////////
			glbarcode::Barcode* Ean8_2::create()
			{
				return new Ean8_2();
			}

		
			bool Ean8_2::validate( const std::string& rawData )
			{
				return isNumericLength1Valid( rawData,  7,  8 ) && isNumericLength2Valid( rawData, 2, 2 );
			}

		
			std::string Ean8_2::encode( const std::string& cookedData )
			{
				flags = BARCODE_EAN;
				return ""; // Actual encoding is done in vectorize
			}
		

			//////////////////////////////////////////////////////
			// EAN-8+5 Barcode
			//////////////////////////////////////////////////////
			glbarcode::Barcode* Ean8_5::create()
			{
				return new Ean8_5();
			}

		
			bool Ean8_5::validate( const std::string& rawData )
			{
				return isNumericLength1Valid( rawData,  7,  8 ) && isNumericLength2Valid( rawData, 5, 5 );
			}

		
			std::string Ean8_5::encode( const std::string& cookedData )
			{
				flags = BARCODE_EAN;
				return ""; // Actual encoding is done in vectorize
			}
		

			//////////////////////////////////////////////////////
			// EAN-13 Barcode
			//////////////////////////////////////////////////////
			glbarcode::Barcode* Ean13::create()
			{
				return new Ean13();
			}

		
			bool Ean13::validate( const std::string& rawData )
			{
				return isNumericLengthValid(  rawData, 12, 13 );
			}

		
			std::string Ean13::encode( const std::string& cookedData )
			{
				flags = BARCODE_EAN;
				return ""; // Actual encoding is done in vectorize
			}
		

			//////////////////////////////////////////////////////
			// EAN-13+2 Barcode
			//////////////////////////////////////////////////////
			glbarcode::Barcode* Ean13_2::create()
			{
				return new Ean13_2();
			}

		
			bool Ean13_2::validate( const std::string& rawData )
			{
				return isNumericLength1Valid( rawData, 12, 13 ) && isNumericLength2Valid( rawData, 2, 2 );
			}

		
			std::string Ean13_2::encode( const std::string& cookedData )
			{
				flags = BARCODE_EAN;
				return ""; // Actual encoding is done in vectorize
			}
		

			//////////////////////////////////////////////////////
			// EAN-13+5 Barcode
			//////////////////////////////////////////////////////
			glbarcode::Barcode* Ean13_5::create()
			{
				return new Ean13_5();
			}

		
			bool Ean13_5::validate( const std::string& rawData )
			{
				return isNumericLength1Valid( rawData, 12, 13 ) && isNumericLength2Valid( rawData, 5, 5 );
			}

		
			std::string Ean13_5::encode( const std::string& cookedData )
			{
				flags = BARCODE_EAN;
				return ""; // Actual encoding is done in vectorize
			}
		

			//////////////////////////////////////////////////////
			// UPC Barcode (Any)
			//////////////////////////////////////////////////////
			glbarcode::Barcode* Upc::create()
			{
				return new Upc();
			}

		
			bool Upc::validate( const std::string& rawData )
			{
				return      isNumericLengthValid( rawData, 6, 8 )
					||  isNumericLengthValid( rawData, 11, 12 )
					|| (isNumericLength1Valid( rawData, 6, 8 ) && isNumericLength2Valid( rawData, 2, 2 ))
					|| (isNumericLength1Valid( rawData, 6, 8 ) && isNumericLength2Valid( rawData, 5, 5 ))
					|| (isNumericLength1Valid( rawData, 11, 12 ) && isNumericLength2Valid( rawData, 2, 2 ))
					|| (isNumericLength1Valid( rawData, 11, 12 ) && isNumericLength2Valid( rawData, 5, 5 ));
			}

		
			std::string Upc::encode( const std::string& cookedData )
			{
				flags = BARCODE_UPC;
				return ""; // Actual encoding is done in vectorize
			}
		

			//////////////////////////////////////////////////////
			// UPC-A Barcode
			//////////////////////////////////////////////////////
			glbarcode::Barcode* UpcA::create()
			{
				return new UpcA();
			}

		
			bool UpcA::validate( const std::string& rawData )
			{
				return isNumericLengthValid( rawData, 11, 12 );
			}

		
			std::string UpcA::encode( const std::string& cookedData )
			{
				flags = BARCODE_UPC;
				return ""; // Actual encoding is done in vectorize
			}
		

			//////////////////////////////////////////////////////
			// UPC-A+2 Barcode
			//////////////////////////////////////////////////////
			glbarcode::Barcode* UpcA_2::create()
			{
				return new UpcA_2();
			}

		
			bool UpcA_2::validate( const std::string& rawData )
			{
				return isNumericLength1Valid( rawData, 11, 12 ) && isNumericLength2Valid( rawData, 2, 2 );
			}

		
			std::string UpcA_2::encode( const std::string& cookedData )
			{
				flags = BARCODE_UPC;
				return ""; // Actual encoding is done in vectorize
			}
		

			//////////////////////////////////////////////////////
			// UPC-A+5 Barcode
			//////////////////////////////////////////////////////
			glbarcode::Barcode* UpcA_5::create()
			{
				return new UpcA_5();
			}

		
			bool UpcA_5::validate( const std::string& rawData )
			{
				return isNumericLength1Valid( rawData, 11, 12 ) && isNumericLength2Valid( rawData, 5, 5 );
			}

		
			std::string UpcA_5::encode( const std::string& cookedData )
			{
				flags = BARCODE_UPC;
				return ""; // Actual encoding is done in vectorize
			}
		

			//////////////////////////////////////////////////////
			// UPC-E Barcode
			//////////////////////////////////////////////////////
			glbarcode::Barcode* UpcE::create()
			{
				return new UpcE();
			}

		
			bool UpcE::validate( const std::string& rawData )
			{
				return isNumericLengthValid( rawData, 6, 8 );
			}

		
			std::string UpcE::encode( const std::string& cookedData )
			{
				flags = BARCODE_UPC;
				return ""; // Actual encoding is done in vectorize
			}
		

			//////////////////////////////////////////////////////
			// UPC-E+2 Barcode
			//////////////////////////////////////////////////////
			glbarcode::Barcode* UpcE_2::create()
			{
				return new UpcE_2();
			}

		
			bool UpcE_2::validate( const std::string& rawData )
			{
				return isNumericLength1Valid( rawData, 6, 8 ) && isNumericLength2Valid( rawData, 2, 2 );
			}

		
			std::string UpcE_2::encode( const std::string& cookedData )
			{
				flags = BARCODE_UPC;
				return ""; // Actual encoding is done in vectorize
			}
		

			//////////////////////////////////////////////////////
			// UPC-E+5 Barcode
			//////////////////////////////////////////////////////
			glbarcode::Barcode* UpcE_5::create()
			{
				return new UpcE_5();
			}

		
			bool UpcE_5::validate( const std::string& rawData )
			{
				return isNumericLength1Valid( rawData, 6, 8 ) && isNumericLength2Valid( rawData, 5, 5 );
			}

		
			std::string UpcE_5::encode( const std::string& cookedData )
			{
				flags = BARCODE_UPC;
				return ""; // Actual encoding is done in vectorize
			}
		

			//////////////////////////////////////////////////////
			// ISBN Barcode
			//////////////////////////////////////////////////////
			glbarcode::Barcode* Isbn::create()
			{
				return new Isbn();
			}

		
			bool Isbn::validate( const std::string& rawData )
			{
				return isNumericLengthValid( rawData, 9, 10 );
			}

		
			std::string Isbn::encode( const std::string& cookedData )
			{
				flags = BARCODE_ISBN;
				return ""; // Actual encoding is done in vectorize
			}
		

			//////////////////////////////////////////////////////
			// ISBN+5 Barcode
			//////////////////////////////////////////////////////
			glbarcode::Barcode* Isbn_5::create()
			{
				return new Isbn_5();
			}

		
			bool Isbn_5::validate( const std::string& rawData )
			{
				return isNumericLength1Valid( rawData, 9, 10 ) && isNumericLength2Valid( rawData, 5, 5 );
			}

		
			std::string Isbn_5::encode( const std::string& cookedData )
			{
				flags = BARCODE_ISBN;
				return ""; // Actual encoding is done in vectorize
			}
		

			//////////////////////////////////////////////////////
			// Code39 Barcode
			//////////////////////////////////////////////////////
			glbarcode::Barcode* Code39::create()
			{
				return new Code39();
			}

		
			bool Code39::validate( const std::string& rawData )
			{
				return isAscii( rawData );
			}

		
			std::string Code39::encode( const std::string& cookedData )
			{
				flags = BARCODE_39;
				return ""; // Actual encoding is done in vectorize
			}
		

			//////////////////////////////////////////////////////
			// Code128 Barcode
			//////////////////////////////////////////////////////
			glbarcode::Barcode* Code128::create()
			{
				return new Code128();
			}

		
			bool Code128::validate( const std::string& rawData )
			{
				return isAscii( rawData );
			}

		
			std::string Code128::encode( const std::string& cookedData )
			{
				flags = BARCODE_128;
				return ""; // Actual encoding is done in vectorize
			}
		

			//////////////////////////////////////////////////////
			// Code128C Barcode
			//////////////////////////////////////////////////////
			glbarcode::Barcode* Code128C::create()
			{
				return new Code128C();
			}

		
			bool Code128C::validate( const std::string& rawData )
			{
				return isAscii( rawData );
			}

		
			std::string Code128C::encode( const std::string& cookedData )
			{
				flags = BARCODE_128C;
				return ""; // Actual encoding is done in vectorize
			}
		

			//////////////////////////////////////////////////////
			// Code128B Barcode
			//////////////////////////////////////////////////////
			glbarcode::Barcode* Code128B::create()
			{
				return new Code128B();
			}

		
			bool Code128B::validate( const std::string& rawData )
			{
				return isAscii( rawData );
			}

		
			std::string Code128B::encode( const std::string& cookedData )
			{
				flags = BARCODE_128B;
				return ""; // Actual encoding is done in vectorize
			}
		

			//////////////////////////////////////////////////////
			// I25 Barcode
			//////////////////////////////////////////////////////
			glbarcode::Barcode* I25::create()
			{
				return new I25();
			}

		
			bool I25::validate( const std::string& rawData )
			{
				return isAscii( rawData );
			}

		
			std::string I25::encode( const std::string& cookedData )
			{
				flags = BARCODE_I25;
				return ""; // Actual encoding is done in vectorize
			}
		

			//////////////////////////////////////////////////////
			// CBR Barcode
			//////////////////////////////////////////////////////
			glbarcode::Barcode* Cbr::create()
			{
				return new Cbr();
			}

		
			bool Cbr::validate( const std::string& rawData )
			{
				return isAscii( rawData );
			}

		
			std::string Cbr::encode( const std::string& cookedData )
			{
				flags = BARCODE_CBR;
				return ""; // Actual encoding is done in vectorize
			}
		

			//////////////////////////////////////////////////////
			// MSI Barcode
			//////////////////////////////////////////////////////
			glbarcode::Barcode* Msi::create()
			{
				return new Msi();
			}

		
			bool Msi::validate( const std::string& rawData )
			{
				return isAscii( rawData );
			}

		
			std::string Msi::encode( const std::string& cookedData )
			{
				flags = BARCODE_MSI;
				return ""; // Actual encoding is done in vectorize
			}
		

			//////////////////////////////////////////////////////
			// PLS Barcode
			//////////////////////////////////////////////////////
			glbarcode::Barcode* Pls::create()
			{
				return new Pls();
			}

		
			bool Pls::validate( const std::string& rawData )
			{
				return isAscii( rawData );
			}

		
			std::string Pls::encode( const std::string& cookedData )
			{
				flags = BARCODE_PLS;
				return ""; // Actual encoding is done in vectorize
			}
		

			//////////////////////////////////////////////////////
			// Code93 Barcode
			//////////////////////////////////////////////////////
			glbarcode::Barcode* Code93::create()
			{
				return new Code93();
			}

		
			bool Code93::validate( const std::string& rawData )
			{
				return isAscii( rawData );
			}

		
			std::string Code93::encode( const std::string& cookedData )
			{
				flags = BARCODE_93;
				return ""; // Actual encoding is done in vectorize
			}
		

		}
	}
}

#endif // HAVE_GNU_BARCODE