//
//  Puzzle.m
//  Demine
//
//  Created by Michael Heyeck on 4/8/10.
//  Copyright 2010 Fair Oaks Labs, Inc.. All rights reserved.
//

#import "Puzzle.h"


const static NSUInteger MAX_EDGE_SIZE	= 500;
const static char BIT_REVEALED			= (1<<5);
const static char BIT_MINED				= (1<<4);
const static char NEIGHBOR_MASK			= 0xf;


static inline char get_record(char* d, int w, int h, int x, int y)
{
	return ((x>=0)&&(x<w)&&(y>=0)&&(y<h))?d[w*y+x]:0;
}

static inline char is_mined(char* d, int w, int h, int x, int y)
{
	return (get_record(d, w, h, x, y)&BIT_MINED)?1:0;
}


@interface Puzzle ()

@property (nonatomic, assign, readonly) char* cells;

@end


@implementation Puzzle

@synthesize w;
@synthesize h;
@synthesize m;

- (char*)cells
{
	if (!cells)
	{
		cells = (char*) malloc(w*h);
	}
	return cells;
}


- (id)initWithWidth:(NSUInteger)iw height:(NSUInteger)ih mines:(NSUInteger)im
{
	if (self = [super init])
	{
		w = MIN(MAX(iw, 2), MAX_EDGE_SIZE);
		h = MIN(MAX(ih, 2), MAX_EDGE_SIZE);
		m = MIN(im, (w-1)*(h-1));
	}
	return self;
}


- (NSString*)description
{
	char symbols[2*w+1];
	memset(symbols, ' ', 2*w+1);
	symbols[0] = '\n';
	symbols[2*w] = '\0';
	NSMutableArray* a = [NSMutableArray arrayWithCapacity:h];

	char* d = self.cells;
	for (int y = 0; y < h; y++)
	{
		for (int x = 0; x < w; x++)
		{
			char cell = d[w*y+x];
			symbols[2*x+1] = (cell&BIT_MINED)?'X':('0'+(cell&NEIGHBOR_MASK));
		}
		[a addObject:[NSString stringWithCString:symbols encoding:NSASCIIStringEncoding]];
	}
	return [a componentsJoinedByString:@""];
}


- (void)generate
{
	char* d = self.cells;
	int size = w*h;
	
	// To keep things reasonable, add or remove cells depending on density
	if (m > size/2)
	{
		// More than 50% mined: remove mines
		memset(d, BIT_MINED, size);
		for (int nmines=size; nmines>m;)
		{
			int idx = rand()%size;
			if (d[idx] & BIT_MINED)
			{
				nmines--;
				d[idx] &= ~BIT_MINED;
			}
		}
	}
	else
	{
		// Less than 50% mined: add mines
		memset(d, 0, size);
		for (int nmines=0; nmines<m;)
		{
			int idx = rand()%size;
			if (!(d[idx] & BIT_MINED))
			{
				nmines++;
				d[idx] |= BIT_MINED;
			}
		}
	}
	
	// Calculate neighbors
	for (int x = w-1; x >= 0; x--)
	{
		for (int y = h-1; y >= 0; y--)
		{
			d[w*y+x] |= (is_mined(d,w,h,x-1,y-1) +
						 is_mined(d,w,h,x+0,y-1) +
						 is_mined(d,w,h,x+1,y-1) +
						 is_mined(d,w,h,x-1,y+0) +
						 is_mined(d,w,h,x+1,y+0) +
						 is_mined(d,w,h,x-1,y+1) +
						 is_mined(d,w,h,x+0,y+1) +
						 is_mined(d,w,h,x+1,y+1) );
		}
	}
}


- (BOOL)isMinedAtX:(NSUInteger)x andY:(NSUInteger)y
{
	return is_mined(self.cells, w, h, x, y);
}


- (NSUInteger)neighborsAtX:(NSUInteger)x andY:(NSUInteger)y
{
	return get_record(self.cells, w, h, x, y)&NEIGHBOR_MASK;
}


- (void)dealloc
{
	if (cells) free(cells);
    [super dealloc];
}

@end