#==== HTML::TocUpdator ========================================================
# function: Update 'HTML::Toc' table of contents.
# note:     - 'TUT' is an abbreviation of 'Toc Update Token'.


package HTML::TocUpdator;


use strict;
use HTML::TocInsertor;


BEGIN {
	use vars qw(@ISA $VERSION);

	$VERSION = '0.91';

	@ISA = qw(HTML::TocInsertor);
}


use constant TUT_TOKENTYPE_START    => 0;
use constant TUT_TOKENTYPE_END      => 1;
use constant TUT_TOKENTYPE_TEXT     => 2;
use constant TUT_TOKENTYPE_COMMENT  => 3;

use constant MODE_DO_NOTHING   => 0;	# 0b00
use constant MODE_DO_INSERT    => 1;	# 0b01
use constant MODE_DO_UPDATE    => 3;	# 0b11


END {}


#--- HTML::TocUpdator::new() --------------------------------------------------
# function: Constructor.

sub new {
		# Get arguments
	my ($aType) = @_;
	my $self = $aType->SUPER::new;
		# Bias to not update ToC
	$self->{htu__Mode} = MODE_DO_NOTHING;
		# Bias to not delete tokens
	$self->{_doDeleteTokens} = 0;
		# Reset batch variables
	#$self->_resetBatchVariables;

	$self->{options} = {};
		
		# TODO: Initialize output

	return $self;
}  # new()


#--- HTML::TocUpdator::_deinitializeUpdatorBatch() --------------------------
# function: Deinitialize updator batch.
# args:     - $aTocs: Reference to array of tocs.

sub _deinitializeUpdatorBatch {
		# Get arguments
	my ($self, $aTocs) = @_;
		# Indicate end of ToC updating
	$self->{htu__Mode} = MODE_DO_NOTHING;
		# Deinitialize insertor batch
	$self->_deinitializeInsertorBatch();
}  # _deinitializeUpdatorBatch()


#--- HTML::TokenUpdator::_doesHashEqualHash() ---------------------------------
# function: Determines whether hash1 equals hash2.
# args:     - $aHash1
#           - $aHash2
# returns:  True (1) if hash1 equals hash2, 0 if not.  For example, with the
#           following hashes:
#
#              %hash1 = {                     %hash2 = {
#                 'class' => 'header',          'class' => 'header',
#                 'id'    => 'intro1'           'id'    => 'intro2'
#              }                             }
#
#           the routine will return 0, cause the hash fields 'id' differ.
# note:     Class function.

sub _doesHashEqualHash {
		# Get arguments
	my ($aHash1, $aHash2) = @_;
		# Local variables
	my ($key1, $value1, $key2, $value2, $result);
		# Bias to success
	$result = 1;
		# Loop through hash1 while values available
	HASH1: while (($key1, $value1) = each %$aHash1) {
		# Yes, values are available;
			# Value1 differs from value2?
		if ($value1 ne $aHash2->{$key1}) {
			# Yes, hashes differ;
				# Indicate condition fails
			$result = 0;
				# Reset 'each' iterator which we're going to break
			keys %$aHash2;
				# Break loop
			last HASH1;
		}
	}
		# Return value
	return $result;
}  # _doesHashEqualHash()


#--- HTML::TokenUpdator::_doesTagExistInArray() -------------------------------
# function: Check whether tag & attributes matches any of the tags & attributes
#           in the specified array.  The array must consist of elements with 
#           format:
#
#              [$tag, \%attributes]
#
# args:     - $aTag: tag to search for
#           - $aAttributes: tag attributes to search for
#           - $aArray: Array to search in.
# returns:  1 if tag does exist in array, 0 if not.
# note:     Class function.

sub _doesTagExistInArray {
		# Get arguments
	my ($aTag, $aAttributes, $aArray) = @_;
		# Local variables
	my ($tag, $result);
		# Bias to non-existing tag
	$result = 0;
		# Loop through existing tags
	TAG: foreach $tag (@{$aArray}) {
		if (defined(@{$tag}[0])) {
				# Does tag equals any existing tag?
			if ($aTag eq @{$tag}[0]) {
				# Yes, tag equals existing tag;
					# Do hashes equal?
				if (HTML::TocUpdator::_doesHashEqualHash(
					$aAttributes, @{$tag}[1]
				)) {
					# Yes, hashes are the same;
						# Indicate tag exists in array
					$result = 1;
						# Break loop
					last TAG;
				}
			}
		}
	}
		# Return value
	return $result;
}  # _doesTagExistInArray()


#--- HTML::TocUpdator::_initializeUpdatorBatch() ----------------------------
# function: Initialize insertor batch.
# args:     - $aMode: Mode.  Can be either MODE_DO_INSERT or MODE_DO_UPDATE
#           - $aTocs: Reference to array of tocs.
#           - $aOptions: optional options
# note:     Updating actually means: deleting the old ToC and inserting a new
#           ToC.  That's why we're calling 'insertor' methods here.

sub _initializeUpdatorBatch {
		# Get arguments
	my ($self, $aMode, $aTocs, $aOptions) = @_;
		# Initialize insertor batch
	$self->_initializeInsertorBatch($aTocs, $aOptions);
		# Parse ToC update templates
	$self->_parseTocUpdateTokens();
		# Indicate start of ToC updating
	$self->{htu__Mode} = $aMode;
}  # _initializeUpdatorBatch()


#--- HTML::TocUpdator::_parseTocUpdateTokens() --------------------------------
# function: Parse ToC insertion point specifier.

sub _parseTocUpdateTokens {
		# Get arguments
	my ($self) = @_;
		# Local variables
	my ($toc, $tokenType, $tokenPreposition, $token);
	my ($tocInsertionPoint, $tocInsertionPointTokenAttributes);
		# Create parser for update begin tokens
	my $tokenUpdateBeginParser = HTML::_TokenUpdateParser->new(
		$self->{_tokensUpdateBegin}
	);
		# Create parser for update end tokens
	my $tokenUpdateEndParser = HTML::_TokenUpdateParser->new(
		$self->{_tokensUpdateEnd}
	);

		# Loop through ToCs
	foreach $toc (@{$self->{_tocs}}) {
			# Parse update tokens
		$tokenUpdateBeginParser->parse(
			$toc->{_tokenUpdateBeginOfAnchorNameBegin}
		);
		$tokenUpdateBeginParser->parse($toc->{_tokenUpdateBeginOfAnchorNameEnd});
		$tokenUpdateBeginParser->parse($toc->{_tokenUpdateBeginNumber});
		$tokenUpdateBeginParser->parse($toc->{_tokenUpdateBeginToc});

		$tokenUpdateEndParser->parse($toc->{_tokenUpdateEndOfAnchorNameBegin});
		$tokenUpdateEndParser->parse($toc->{_tokenUpdateEndOfAnchorNameEnd});
		$tokenUpdateEndParser->parse($toc->{_tokenUpdateEndNumber});
		$tokenUpdateEndParser->parse($toc->{_tokenUpdateEndToc});
	}
}  # _parseTocUpdateTokens()


#--- HTML::TocUpdator::_resetBatchVariables() ---------------------------------
# function: Reset batch variables

sub _resetBatchVariables {
		# Get arguments
	my ($self) = @_;
		# Call ancestor
	$self->SUPER::_resetBatchVariables();
		# Arrays containing start, end, comment & text tokens which indicate
		# the begin of ToC tokens.  The tokens are stored in keys of hashes to 
		# avoid storing duplicates as an array would.
	$self->{_tokensUpdateBegin} = [
		[],	# ['<start tag>', <attributes>]
		{},	# {'<end tag>' => ''}
		{},	# {'<text>'    => ''}
		{}		# {'<comment>' => ''}
	];
		# Arrays containing start, end, comment & text tokens which indicate
		# the end of ToC tokens.  The tokens are stored in keys of hashes to 
		# avoid storing duplicates as an array would.
	$self->{_tokensUpdateEnd} = [
		[],	# ['<start tag>', <attributes>]
		{},	# {'<end tag>' => ''}
		{},	# {'<text>'    => ''}
		{}		# {'<comment>' => ''}
	];
}  # _resetBatchVariables()


#--- HTML::TocUpdator::_setActiveAnchorName() ---------------------------------
# function: Set active anchor name.
# args:     - aAnchorName: Name of anchor name to set active.

sub _setActiveAnchorName {
		# Get arguments
	my ($self, $aAnchorName) = @_;
		# Are tokens being deleted?
	if (! $self->{_doDeleteTokens}) {
		# No, tokens aren't being deleted;
			# Call ancestor to set anchor name
		$self->SUPER::_setActiveAnchorName($aAnchorName);
	}
}  # _setActiveAnchorName()


#--- HTML::TocUpdator::_update() ----------------------------------------------
# function: Update ToC in string.
# args:     - $aMode: Mode.  Can be either MODE_DO_UPDATE or MODE_DO_INSERT.
#           - $aToc: (reference to array of) ToC object to update
#           - $aString: string to update ToC of
#           - $aOptions: optional updator options
# note:     Used internally.

sub _update {
		# Get arguments
	my ($self, $aMode, $aToc, $aString, $aOptions) = @_;
		# Initialize TocUpdator batch
	$self->_initializeUpdatorBatch($aMode, $aToc, $aOptions);
		# Start updating ToC by starting ToC insertion
	$self->_insert($aString);
		# Deinitialize TocUpdator batch
	$self->_deinitializeUpdatorBatch();
}  # update()


#--- HTML::TocUpdator::_updateFile() ------------------------------------------
# function: Update ToCs in file.
# args:     - $aMode: Mode.  Can be either MODE_DO_UPDATE or MODE_DO_INSERT.
#           - $aToc: (reference to array of) ToC object to update
#           - $aFile: (reference to array of) file to parse for updating.
#           - $aOptions: optional updator options
# note:     Used internally.

sub _updateFile {
		# Get arguments
	my ($self, $aMode, $aToc, $aFile, $aOptions) = @_;
		# Initialize TocUpdator batch
	$self->_initializeUpdatorBatch($aMode, $aToc, $aOptions);
		# Start updating ToC by starting ToC insertion
	$self->_insertIntoFile($aFile);
		# Deinitialize TocUpdator batch
	$self->_deinitializeUpdatorBatch();
}  # _updateFile()


#--- HTML::TocUpdator::_writeOrBufferOutput() ---------------------------------
# function: Write processed HTML to output device(s).
# args:     - aOutput: scalar to write

sub _writeOrBufferOutput {
		# Get arguments
	my ($self, $aOutput) = @_;
		# Delete output?
	if (! $self->{_doDeleteTokens}) {
		# No, don't delete output;
			# Call ancestor
		$self->SUPER::_writeOrBufferOutput($aOutput);
	}
}  # _writeOrBufferOutput()


#--- HTML::TocUpdator::anchorNameBegin() --------------------------------------
# function: Process 'anchor name begin' generated by HTML::Toc.
# args:     - $aAnchorName: Anchor name begin tag to output.
#           - $aToc: Reference to ToC to which anchorname belongs.

sub anchorNameBegin {
		# Get arguments
	my ($self, $aAnchorNameBegin, $aToc) = @_;
		# Call ancestor
	$self->SUPER::anchorNameBegin($aAnchorNameBegin);
		# Must ToC be inserted or updated?
	if ($self->{htu__Mode} != MODE_DO_NOTHING) {
		# Yes, ToC must be inserted or updated;
			# Surround anchor name with update tags
		$self->{_outputPrefix} = 
			$aToc->{_tokenUpdateBeginOfAnchorNameBegin} .
			$self->{_outputPrefix} . 
			$aToc->{_tokenUpdateEndOfAnchorNameBegin};
	}
}	# anchorNameBegin()


#--- HTML::TocUpdator::anchorNameEnd() ----------------------------------------
# function: Process 'anchor name end' generated by HTML::Toc.
# args:     - $aAnchorNameEnd: Anchor name end tag to output.
#           - $aToc: Reference to ToC to which anchorname belongs.

sub anchorNameEnd {
		# Get arguments
	my ($self, $aAnchorNameEnd, $aToc) = @_;
		# Call ancestor
	$self->SUPER::anchorNameEnd($aAnchorNameEnd);
		# Must ToC be inserted or updated?
	if ($self->{htu__Mode} != MODE_DO_NOTHING) {
		# Yes, ToC must be inserted or updated;
			# Surround anchor name with update tags
		$self->{_outputSuffix} = 
			$aToc->{_tokenUpdateBeginOfAnchorNameEnd} .
			$self->{_outputSuffix} . 
			$aToc->{_tokenUpdateEndOfAnchorNameEnd};
	}
}	# anchorNameEnd()


#--- HTML::TocUpdator::comment() ----------------------------------------------
# function: Process comment.
# args:     - $aComment: comment text with '<!--' and '-->' tags stripped off.

sub comment {
		# Get arguments
	my ($self, $aComment) = @_;
		# Must ToC be updated?
	if ($self->{htu__Mode} == MODE_DO_UPDATE) {
		# Yes, ToC must be updated;
			# Updator is currently deleting tokens?
		if ($self->{_doDeleteTokens}) {
			# Yes, tokens must be deleted;
				# Call ancestor
			$self->SUPER::comment($aComment);

				# Look for update end token

				# Does comment matches update end token?
			if (defined(
				$self->{_tokensUpdateEnd}[TUT_TOKENTYPE_COMMENT]{$aComment}
			)) {
				# Yes, comment matches update end token;
					# Indicate to stop deleting tokens
				$self->{_doDeleteTokens} = 0;
			}
		}
		else {
			# No, tokens mustn't be deleted;

				# Look for update begin token

				# Does comment matches update begin token?
			if (defined(
				$self->{_tokensUpdateBegin}[TUT_TOKENTYPE_COMMENT]{$aComment}
			)) {
				# Yes, comment matches update begin token;
					# Indicate to start deleting tokens
				$self->{_doDeleteTokens} = 1;
			}
				# Call ancestor
			$self->SUPER::comment($aComment);
		}
	}
	else {
		# No, ToC mustn't be updated;
			# Call ancestor
		$self->SUPER::comment($aComment);
	}
}  # comment()


#--- HTML::TocUpdator::end() --------------------------------------------------
# function: This function is called every time a closing tag is encountered.
# args:     - $aTag: tag name (in lower case).
#           - $aOrigText: tag name including brackets.

sub end {
		# Get arguments
	my ($self, $aTag, $aOrigText) = @_;
		# Call ancestor
	$self->SUPER::end($aTag, $aOrigText);
		# Must ToC be updated?
	if ($self->{htu__Mode} == MODE_DO_UPDATE) {
		# Yes, ToC must be updated;
			# Updator is currently deleting tokens?
		if ($self->{_doDeleteTokens}) {
			# Yes, tokens must be deleted;
				# Does end tag matches update end token?
			if (defined(
				$self->{_tokensUpdateEnd}[TUT_TOKENTYPE_END]{$aTag}
			)) {
				# Yes, end tag matches update end token;
					# Indicate to stop deleting tokens
				$self->{_doDeleteTokens} = 0;
			}
		}
	}
}  # end()


#--- HTML::TocUpdator::insert() -----------------------------------------------
# function: Insert ToC in string.
# args:     - $aToc: (reference to array of) ToC object to update
#           - $aString: string to insert ToC in.
#           - $aOptions: optional updator options

sub insert {
		# Get arguments
	my ($self, $aToc, $aString, $aOptions) = @_;
		# Do start insert
	$self->_update(MODE_DO_INSERT, $aToc, $aString, $aOptions);
}  # insert()


#--- HTML::TocUpdator::insertIntoFile() --------------------------------------
# function: Insert ToC in file.
# args:     - $aToc: (reference to array of) ToC object to update
#           - $aFile: File to insert ToC in.
#           - $aOptions: optional updator options

sub insertIntoFile {
		# Get arguments
	my ($self, $aToc, $aFile, $aOptions) = @_;
		# Do start insert
	$self->_updateFile(MODE_DO_INSERT, $aToc, $aFile, $aOptions);
}  # insertIntoFile()


#--- HTML::TocUpdator::number() -----------------------------------------------
# function: Process heading number generated by HTML::Toc.
# args:     - $aNumber
#           - $aToc: Reference to ToC to which anchorname belongs.

sub number {
		# Get arguments
	my ($self, $aNumber, $aToc) = @_;
		# Call ancestor
	$self->SUPER::number($aNumber);
		# Must ToC be inserted or updated?
	if ($self->{htu__Mode} != MODE_DO_NOTHING) {
		# Yes, ToC must be inserted or updated;
			# Surround number with update tags
		$self->{_outputSuffix} = 
			$aToc->{_tokenUpdateBeginNumber} .
			$self->{_outputSuffix} . 
			$aToc->{_tokenUpdateEndNumber};
	}
}	# number()


#--- HTML::TocUpdator::start() ------------------------------------------------
# function: This function is called every time an opening tag is encountered.
# args:     - $aTag: tag name (in lower case).
#           - $aAttr: reference to hash containing all tag attributes (in lower
#                case).
#           - $aAttrSeq: reference to array containing all tag attributes (in 
#                lower case) in the original order
#           - $aOrigText: the original HTML text

sub start {
		# Get arguments
	my ($self, $aTag, $aAttr, $aAttrSeq, $aOrigText) = @_;
		# Must ToC be updated?
	if ($self->{htu__Mode} == MODE_DO_UPDATE) {
		# Yes, ToC must be updated;
			# Does start tag matches token update begin tag?
		if (HTML::TocUpdator::_doesTagExistInArray(
			$aTag, $aAttr, $self->{_tokensUpdateBegin}[TUT_TOKENTYPE_START]
		)) {
			# Yes, start tag matches token update tag;
				# Indicate to delete tokens
			$self->{_doDeleteTokens} = 1;
		}
	}
		# Let ancestor process the start tag
	$self->SUPER::start($aTag, $aAttr, $aAttrSeq, $aOrigText);
}  # start()


#--- HTML::TocUpdator::toc() --------------------------------------------------
# function: Toc processing method.  Add toc reference to scenario.
# args:     - $aScenario: Scenario to add ToC reference to.
#           - $aToc: Reference to ToC to insert.
# note:     The ToC hasn't been build yet; only a reference to the ToC to be
#           build is inserted.

sub toc {
		# Get arguments
	my ($self, $aScenario, $aToc) = @_;

		# Surround toc with update tokens

		# Add update begin token
	push(@$aScenario, \$aToc->{_tokenUpdateBeginToc});
		# Call ancestor
	$self->SUPER::toc($aScenario, $aToc);
		# Add update end token
	push(@$aScenario, \$aToc->{_tokenUpdateEndToc});
}  # toc()


#--- HTML::TocUpdator::_processTocText() --------------------------------------
# function: Toc text processing function.
# args:     - $aText: Text to add to ToC.
#           - $aToc: ToC to add text to.

sub _processTocText {
		# Get arguments
	my ($self, $aText, $aToc) = @_;
		# Delete output?
	if (! $self->{_doDeleteTokens}) {
		# No, don't delete output;
			# Call ancestor
		$self->SUPER::_processTocText($aText, $aToc);
	}
}  # _processTocText()


#--- HTML::TocUpdator::update() -----------------------------------------------
# function: Update ToC in string.
# args:     - $aToc: (reference to array of) ToC object to update
#           - $aString: string to update ToC of
#           - $aOptions: optional updator options

sub update {
		# Get arguments
	my ($self, $aToc, $aString, $aOptions) = @_;
		# Do start update
	$self->_update(MODE_DO_UPDATE, $aToc, $aString, $aOptions);
}  # update()


#--- HTML::TocUpdator::updateFile() -------------------------------------------
# function: Update ToC of file.
# args:     - $aToc: (reference to array of) ToC object to update
#           - $aFile: (reference to array of) file to parse for updating.
#           - $aOptions: optional updator options

sub updateFile {
		# Get arguments
	my ($self, $aToc, $aFile, $aOptions) = @_;
		# Do start update
	$self->_updateFile(MODE_DO_UPDATE, $aToc, $aFile, $aOptions);
}  # update()


#=== HTML::_TokenUpdateParser =================================================
# function: Parse 'update tokens'.  'Update tokens' mark HTML code which is
#           inserted by 'HTML::TocInsertor'.
# note:     Used internally.

package HTML::_TokenUpdateParser;


BEGIN {
	use vars qw(@ISA);

	@ISA = qw(HTML::Parser);
}

END {}


#--- HTML::_TokenUpdateParser::new() ------------------------------------------
# function: Constructor

sub new {
		# Get arguments
	my ($aType, $aTokenArray) = @_;
		# Create instance
	my $self = $aType->SUPER::new;
		# Reference token array
	$self->{tokens} = $aTokenArray;
		# Return instance
	return $self;
}  # new()


#--- HTML::_TokenUpdateParser::comment() --------------------------------------
# function: Process comment.
# args:     - $aComment: comment text with '<!--' and '-->' tags stripped off.

sub comment {
		# Get arguments
	my ($self, $aComment) = @_;
		# Add token to array of update tokens
	$self->{tokens}[HTML::TocUpdator::TUT_TOKENTYPE_COMMENT]{$aComment} = '';
}  # comment()


#--- HTML::_TokenUpdateParser::end() ------------------------------------------
# function: This function is called every time a closing tag is encountered
#           by HTML::Parser.
# args:     - $aTag: tag name (in lower case).

sub end {
		# Get arguments
	my ($self, $aTag, $aOrigText) = @_;
		# Add token to array of update tokens
	$self->{tokens}[HTML::TocUpdator::TUT_TOKENTYPE_END]{$aTag} = '';
}  # end()


#--- HTML::_TokenUpdateParser::parse() ----------------------------------------
# function: Parse token.
# args:     - $aToken: 'update token' to parse

sub parse {
		# Get arguments
	my ($self, $aString) = @_;
		# Call ancestor
	$self->SUPER::parse($aString);
}  # parse()


#--- HTML::_TokenUpdateParser::start() ----------------------------------------
# function: This function is called every time an opening tag is encountered.
# args:     - $aTag: tag name (in lower case).
#           - $aAttr: reference to hash containing all tag attributes (in lower
#                case).
#           - $aAttrSeq: reference to array containing all tag attributes (in 
#                lower case) in the original order
#           - $aOrigText: the original HTML text

sub start {
		# Get arguments
	my ($self, $aTag, $aAttr, $aAttrSeq, $aOrigText) = @_;
		# Does token exist in array?
	if (! HTML::TocUpdator::_doesTagExistInArray(
		$aTag, $aAttr, $self->{tokens}[HTML::TocUpdator::TUT_TOKENTYPE_START]
	)) {
		# No, token doesn't exist in array;
			# Add token to array of update tokens
		push(
			@{$self->{tokens}[HTML::TocUpdator::TUT_TOKENTYPE_START]},
			[$aTag, $aAttr]
		);
	}
}  # start()


#--- HTML::_TokenUpdateParser::text() -----------------------------------------
# function: This function is called every time plain text is encountered.
# args:     - @_: array containing data.

sub text {
		# Get arguments
	my ($self, $aText) = @_;
		# Add token to array of update tokens
	$self->{tokens}[HTML::TocUpdator::TUT_TOKENTYPE_TEXT]{$aText} = '';
}  # text()


1;