pub usingnamespace @import("board.zig");

const mask_not_a = 0xfefefefefefefefe;
const mask_not_ab = 0xfcfcfcfcfcfcfcfc;
const mask_not_h = 0x7f7f7f7f7f7f7f7f;
const mask_not_gh = 0x3f3f3f3f3f3f3f3f;

const pawn_attacks = initPawnAttacks();

fn initPawnAttacks() [2][64]u64 {
    comptime {
        var sq: u8 = 0;
        var attacks: [2][64]u64 = undefined;
        while (sq < 64) : (sq += 1) {
            attacks[0][sq] = maskPawnAttacks(Side.White, @intToEnum(Square, sq));
        }
        sq = 0;
        while (sq < 64) : (sq += 1) {
            attacks[1][sq] = maskPawnAttacks(Side.Black, @intToEnum(Square, sq));
        }
        return attacks;
    }
}

fn maskPawnAttacks(side: Side, pawn: Square) u64 {
    const bitboard = bitboardFromSquare(pawn);
    return switch (side) {
        Side.White => (bitboard >> 9 & mask_not_h) | (bitboard >> 7 & mask_not_a),
        Side.Black => (bitboard << 9 & mask_not_a) | (bitboard << 7 & mask_not_h),
    };
}

pub fn pawnAttacks(side: Side, pawn: Square) u64 {
    return pawn_attacks[@enumToInt(side)][@enumToInt(pawn)];
}

const knight_attacks = initKnightAttacks();

fn initKnightAttacks() [64]u64 {
    comptime {
        var sq: u8 = 0;
        var attacks: [64]u64 = undefined;
        while (sq < 64) : (sq += 1) {
            attacks[sq] = maskKnightAttacks(@intToEnum(Square, sq));
        }
        return attacks;
    }
}

fn maskKnightAttacks(knight: Square) u64 {
    const bitboard = bitboardFromSquare(knight);
    // attacks considered clockwise
    var attacks = bitboard >> 15 & mask_not_a;
    attacks |= bitboard >> 6 & mask_not_ab;
    attacks |= bitboard << 10 & mask_not_ab;
    attacks |= bitboard << 17 & mask_not_a;
    attacks |= bitboard << 15 & mask_not_h;
    attacks |= bitboard << 6 & mask_not_gh;
    attacks |= bitboard >> 10 & mask_not_gh;
    attacks |= bitboard >> 17 & mask_not_h;
    return attacks;
}

pub fn knightAttacks(knight: Square) u64 {
    return knight_attacks[@enumToInt(knight)];
}

const king_attacks = initKingAttacks();

fn initKingAttacks() [64]u64 {
    comptime {
        var sq: u8 = 0;
        var attacks: [64]u64 = undefined;
        while (sq < 64) : (sq += 1) {
            attacks[sq] = maskKingAttacks(@intToEnum(Square, sq));
        }
        return attacks;
    }
}

fn maskKingAttacks(king: Square) u64 {
    const bitboard = bitboardFromSquare(king);
    var attacks = bitboard >> 8;
    attacks |= bitboard >> 7 & mask_not_a;
    attacks |= bitboard << 1 & mask_not_a;
    attacks |= bitboard << 9 & mask_not_a;
    attacks |= bitboard << 8;
    attacks |= bitboard << 7 & mask_not_h;
    attacks |= bitboard >> 1 & mask_not_h;
    attacks |= bitboard >> 9 & mask_not_h;
    return attacks;
}

pub fn kingAttacks(king: Square) u64 {
    return king_attacks[@enumToInt(king)];
}