#pragma once

#include <iostream>
using namespace std;

class Point
{
private:
    int x;
    int y;

public:
    Point(void);
    Point( int x, int y );
    Point( const Point &xPoint );
    ~Point(void);

    void setX( int x );
    int getX() const;

    void setY( int y );
    int getY() const;

    Point & operator = ( const Point &xPoint );
    bool operator == ( const Point &xPoint ) const;

    bool includes( int cord_X, int cord_Y ) const;

    void draw() const;
};

#pragma once

#include "Point.h"

const int MAX = 100;

class PointCollection
{
private:
    Point pts[ MAX ];
    int quantity;

public:
    PointCollection( void );
    PointCollection( const PointCollection &xPointCollection );
    ~PointCollection( void );

    // To know how many Points are
    // ..in the collection
    int size() const; 

    PointCollection operator = ( const PointCollection &xPointCollection );
    
    Point &operator[]( int index );
    //const Point &operator[]( int index ) const;

    bool isFull() const;
    bool isEmpty() const;

    bool includes( const Point &xPoint ) const;
    int indexOf( const Point &xPoint ) const;
};

#include "Point.h"

Point::Point( void )
{
    this->x = 0;
    this->y = 0;
}

Point::Point( int x, int y )
{
    this->x = x;
    this->y = y;
}

Point::Point( const Point &xPoint )
{
    this->x = xPoint.x;
    this->y = xPoint.x;
}

Point::~Point( void ){} // Destructor

//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

void Point::setX( int x ) // set X
{
    this->x = x;
}

void Point::setY( int y ) // set Y
{
    this->y = y;
}


int Point::getX() const // get X
{
    return ( this->x );
}

int Point::getY() const // get Y
{
    return ( this->y );
}

//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Point &Point::operator = ( const Point &xPoint )
{
    if( this != &xPoint )
    {
	this->x = xPoint.x;
	this->y = xPoint.y;
    }

    return ( *this );
}

bool Point::operator == ( const Point &xPoint ) const
{
    bool isEquality = false;
    if( this->x == xPoint.x &&
        this->y == xPoint.y )
    {
	isEquality = true;
    }
    return isEquality;
}

bool Point::includes( int cord_X, int cord_Y ) const
{
    return ( this->x == cord_X && this->y == cord_Y );
}

void Point::draw() const
{
    cout << '.';
}

#include "PointCollection.h"

PointCollection::PointCollection( void )
{
    this->quantity = 0;
}

PointCollection::PointCollection( const PointCollection &xPointCollection )
{
    this->quantity = xPointCollection.quantity;

    for ( int i = 0; i < this->quantity; i++ )
	( this->pts )[ i ] = ( xPointCollection.pts )[ i ];
}

PointCollection::~PointCollection( void ) {}

//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

int PointCollection::size() const
{
    return ( this->quantity );
}

//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Point &PointCollection::operator []( int index )
{
    return ( ( this->pts )[ index ] );
}

/*
const Point &PointCollection::operator []( int index ) const
{
    return ( ( this->pts )[ index ] );
}
*/

//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

PointCollection PointCollection::operator =( const PointCollection &xPointCollection )
{
    this->quantity = xPointCollection.quantity;

    for ( int i = 0; i < this->quantity; i++ )
	( this->pts )[ i ] = ( xPointCollection.pts )[ i ];

    return ( *this );
}

//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

bool PointCollection::isFull() const
{
    return ( this->quantity == MAX );
}

bool PointCollection::isEmpty() const
{
    return ( this->quantity == 0 );
}

//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

bool PointCollection::includes( const Point &xPoint ) const
{
    bool thisOne = false;

    for ( int i = 0; i < this->quantity && ! thisOne; i++ )
    {
	//if ( ( *this )[ i ] == xPoint )
	if( pts[ i ] == xPoint )
	    thisOne = true;
    }

    return ( thisOne );
}

int PointCollection::indexOf( const Point &xPoint ) const
{
    int index = -1;

    for ( int i = 0; i < this->quantity && index == -1; i++ )
    {
	//if ( ( *this )[ i ] == xPoint )
	if( pts[ i ] == xPoint )
	    index = i; // I'd add a break here to end "early" if found
    }

    return ( index );
}

#pragma once

#include "PointCollection.h"

class Page
{
private:
	int heigh;
	int width;

public:
	Page( void );
	Page( int width, int heigh );
	Page( const Page &xPage );
	~Page( void );

	void setWidth( int width );
	int getWidth() const;

	void setHeigh( int heigh );
	int getHeigh() const;

	void draw() const;
};

#include "Page.h"

Page::Page( void )
{
	this->width = 0;
	this->heigh = 0;
}

Page::Page( int width, int heigh )
{
	this->width = width;
	this->heigh = heigh;
}

Page::Page( const Page &xPage )
{
	this->width = xPage.width;
	this->heigh = xPage.heigh;
}

Page::~Page( void ) {}

//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

void Page::setHeigh( int heigh )
{
	this->heigh = heigh;
}

void Page::setWidth( int width )
{
	this->width = width;
}

int Page::getHeigh() const
{
	return ( this->heigh );
}

int Page::getWidth() const
{
	return ( this->width );
}

//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

void Page::draw() const
{
	bool included;

	for( int y = 0 ; y < this->heigh ; y++ )
	{
		for ( int x = 0; x < this->width ; x++ )
		{
			for ( int p = 0 ; p < PointCollection.size()  && !included ; p++ )
			{

				if ( PointCollection[ p ].includes( x, y ) )
				{
					PointCollection[ p ].draw();
					included = true;
				}

				if ( included )
					cout << ' ';
			}
		}
		cout << endl;
	}
}