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

//  A Set of Tools for Exploring Mazes

//

//  test_maze.h (libcoyote)

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

//

//  COPYRIGHT NOTICE, DISCLAIMER, and LICENSE:

//  

//  If you modify this file, you may insert additional notices

//  immediately following this sentence.

//  

//  Copyright 2001, 2004 Scott Robert Ladd.

//  All rights reserved, except as noted herein.

//  

//  This computer program source file is supplied "AS IS". Scott Robert

//  Ladd (hereinafter referred to as "Author") disclaims all warranties,

//  expressed or implied, including, without limitation, the warranties

//  of merchantability and of fitness for any purpose. The Author

//  assumes no liability for direct, indirect, incidental, special,

//  exemplary, or consequential damages, which may result from the use

//  of this software, even if advised of the possibility of such damage.

//  

//  The Author hereby grants anyone permission to use, copy, modify, and

//  distribute this source code, or portions hereof, for any purpose,

//  without fee, subject to the following restrictions:

//  

//      1. The origin of this source code must not be misrepresented.

//  

//      2. Altered versions must be plainly marked as such and must not

//         be misrepresented as being the original source.

//  

//      3. This Copyright notice may not be removed or altered from any

//         source or altered source distribution.

//  

//  The Author specifically permits (without fee) and encourages the use

//  of this source code for entertainment, education, or decoration. If

//  you use this source code in a product, acknowledgment is not required

//  but would be appreciated.

//  

//  Acknowledgement:

//      This license is based on the wonderful simple license that

//      accompanies libpng.

//

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

//  For more information on this software package, please visit

//  Scott's web site, Coyote Gulch Productions, at:

//

//      http://www.coyotegulch.com

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


#include <iostream>

#include <fstream>

#include <iomanip>

#include <ctime>

using namespace std;

#include "../libcoyotl/mwc1038.h"

#include "../libcoyotl/maze.h"

#include "../libcoyotl/maze_recursive.h"

#include "../libcoyotl/maze_renderer.h"

using namespace libcoyotl;

#if defined(_DEBUG)

ostream & operator << (ostream & target, const maze & source)
{
    static const string dir_names[4] = { " N", " E", " S", " W" };

    for (size_t col = 0; col < source.get_width(); ++col)
    {
        for (size_t row = 0; row < source.get_height(); ++row)
        {
            target << "[" << setw(2) << col << "," << setw(2) << row << "] walls =";

            maze::cell cell = source.get_cell(col,row);

            for (size_t dir = maze::DIR_NORTH; dir <= maze::DIR_WEST; ++dir)
                target << dir_names[dir] << (*cell.m_walls[dir]);

            target << endl;
        }
    }

    return target;
}
#endif


int main(int argc, char * argv[])
{
    cout << endl;

    // default arguments -- yes, I know this is very simple, but it's a test program, darn it...

    string image_name("maze.png");
    int width     =  997;
    int height    = 1001;
    int grid_size =   11;

    mwc1038 randomizer;
    string maze_data_name(image_name + ".maze");
    string restored_image_name("restored_");
    restored_image_name += image_name;

    try
    {
        // keep track of run time

        clock_t start = clock();

        // create an architect object

        recursive_maze_architect architect(randomizer);

        // create the maze

        cout << "generating a " << width << "-by-" << height << " maze" << endl;
        maze m1 = maze::generate(width,height,architect);

        // draw it to a PNG file

        cout << "writing maze image to " << image_name << " (grid size " << grid_size << ")" << endl;
        maze_renderer::render(m1,image_name,grid_size);

        // save maze data

        cout << "writing maze data to " << maze_data_name << endl;
        ofstream file_out(maze_data_name.c_str(),ios::binary | ios::out | ios::trunc);
        m1.save(file_out);
        file_out.close();

        // restore maze data from file

        cout << "reading maze data" << endl;
        ifstream file_in(maze_data_name.c_str(),ios::binary | ios::in);
        maze m2 = maze::load(file_in);
        file_in.close();

        // write restored image to PNG file

        cout << "writing restored maze image to " << restored_image_name << endl;
        maze_renderer::render(m2,restored_image_name,grid_size);

        // dump mazes for debugging

#if defined(_DEBUG)

        cout << endl
             << "Maze m1 dump:" << endl << m1 << endl
             << "Maze m2 dump:" << endl << m2 << endl;
#endif


        // done

        cout << "done in " << (double(clock() - start) / CLOCKS_PER_SEC) << " seconds" << endl;

    }
    catch (exception & ex)
    {
        cerr << "** EXCEPTION: " << ex.what() << endl;
        return 1;
    }
    catch (...)
    {
        cerr << "** UNKNOWN EXCEPTION **" << endl;
        return 2;
    }

    // outa here!

    return 0;
}