// Copyright (C) 2011 Red Hat, Inc. All rights reserved.
//
// This file is part of the thin-provisioning-tools source.
//
// thin-provisioning-tools 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.
//
// thin-provisioning-tools 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 thin-provisioning-tools.  If not, see
// <http://www.gnu.org/licenses/>.

#ifndef METADATA_CHECKER_H
#define METADATA_CHECKER_H

#include "persistent-data/block.h"
#include "persistent-data/error_set.h"
#include "persistent-data/space_map.h"

#include "thin-provisioning/range.h"

#include <deque>

//----------------------------------------------------------------

namespace thin_provisioning {
	class metadata_damage_visitor;

	// Base class for all types of metadata damage.  Used in reporting.
	class metadata_damage {
	public:
		typedef boost::shared_ptr<metadata_damage> ptr;
		virtual ~metadata_damage() {}
		virtual void visit(metadata_damage_visitor &visitor) const = 0;

		void set_message(std::string const &message);
		std::string const &get_message() const;

	private:
		std::string message_;
	};

	// FIXME: there's a mix of abstraction here, some classes represent
	// the actual damage on disk (bad_ref_count), others represent the
	// repercussions (missing_mapping).  Need to revist, probably once
	// we've got the reporting layer in.

	class super_block_corruption : public metadata_damage {
		void visit(metadata_damage_visitor &visitor) const;
		bool operator ==(super_block_corruption const &rhs) const;
	};

	typedef range<uint64_t> range64;

	struct missing_device_details : public metadata_damage {
		missing_device_details(range64 missing);
		virtual void visit(metadata_damage_visitor &visitor) const;
		bool operator ==(missing_device_details const &rhs) const;

		range64 missing_;
	};

	struct missing_devices : public metadata_damage {
		missing_devices(range64 missing);
		virtual void visit(metadata_damage_visitor &visitor) const;
		bool operator ==(missing_devices const &rhs) const;

		range64 missing_;
	};

	struct missing_mappings : public metadata_damage {
		missing_mappings(uint64_t dev, range64 missing);
		virtual void visit(metadata_damage_visitor &visitor) const;
		bool operator ==(missing_mappings const &rhs) const;

		uint64_t dev_;
		range64 missing_;
	};

	struct bad_metadata_ref_count : public metadata_damage {
		bad_metadata_ref_count(block_address b,
				       ref_t actual,
				       ref_t expected);

		virtual void visit(metadata_damage_visitor &visitor) const;
		bool operator ==(bad_metadata_ref_count const &rhs) const;

		block_address b_;
		ref_t actual_;
		ref_t expected_;
	};

	struct bad_data_ref_count : public metadata_damage {
		bad_data_ref_count(block_address b,
				   ref_t actual,
				   ref_t expected);

		virtual void visit(metadata_damage_visitor &visitor) const;
		bool operator ==(bad_data_ref_count const &rhs) const;

		block_address b_;
		ref_t actual_;
		ref_t expected_;
	};

	struct missing_metadata_ref_counts : public metadata_damage {
		missing_metadata_ref_counts(range64 missing);
		virtual void visit(metadata_damage_visitor &visitor) const;
		bool operator ==(missing_metadata_ref_counts const &rhs) const;

		range64 missing_;
	};

	struct missing_data_ref_counts : public metadata_damage {
		missing_data_ref_counts(range64 missing);
		virtual void visit(metadata_damage_visitor &visitor) const;
		bool operator ==(missing_data_ref_counts const &rhs) const;

		range64 missing_;
	};

	class metadata_damage_visitor {
	public:
		typedef boost::shared_ptr<metadata_damage_visitor> ptr;

		virtual ~metadata_damage_visitor() {}

		void visit(metadata_damage const &damage);
		virtual void visit(super_block_corruption const &damage) = 0;
		virtual void visit(missing_device_details const &damage) = 0;
		virtual void visit(missing_devices const &damage) = 0;
		virtual void visit(missing_mappings const &damage) = 0;
		virtual void visit(bad_metadata_ref_count const &damage) = 0;
		virtual void visit(bad_data_ref_count const &damage) = 0;
		virtual void visit(missing_metadata_ref_counts const &damage) = 0;
		virtual void visit(missing_data_ref_counts const &damage) = 0;
	};

	typedef std::deque<metadata_damage::ptr> damage_list;
	typedef boost::shared_ptr<damage_list> damage_list_ptr;

	//--------------------------------

	class checker {
	public:
		typedef persistent_data::block_manager<> block_manager;
		typedef boost::shared_ptr<checker> ptr;

		checker(block_manager::ptr bm);

		virtual ~checker() {};
		virtual damage_list_ptr check() = 0;

	protected:
		block_manager::ptr bm_;
	};
}

//----------------------------------------------------------------

#endif