#!/usr/bin/env python
# -*- encoding: utf-8 -*-
##
## Copyright (C) 2011 Thibaut Girka <thib@sitedethib.com>
##
## This program 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; version 3 only.
##
## This program 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.
##

import argparse
import os
import sys

import pyximport
pyximport.install()

from pytouhou.resource.loader import Loader
from pytouhou.game.background import Background
from pytouhou.ui.gamerunner import GameRunner
from pytouhou.games.eosd import EoSDGame
from pytouhou.game.game import GameOver
from pytouhou.game.player import PlayerState
from pytouhou.formats.t6rp import T6RP
from pytouhou.utils.random import Random
from pytouhou.vm.msgrunner import NextStage


class EoSDGameBossRush(EoSDGame):
    def run_iter(self, keystate):
        for i in range(20):
            EoSDGame.run_iter(self, (keystate | 256) if i == 0 else 0)
            if not self.enemies and self.frame % 90 == 0:
                for player in self.players:
                    if player.state.power < 128:
                        player.state.power += 1
            if (self.enemies or self.items
                or self.lasers or self.bullets or self.cancelled_bullets):
                break

    def cleanup(self):
        if not (self.boss or self.msg_wait or self.ecl_runner.boss_wait):
            self.enemies = [enemy for enemy in self.enemies
                                if enemy.boss_callback != -1 or enemy.frame > 1]
            self.lasers = [laser for laser in self.lasers if laser.frame > 1]
            self.bullets = [bullet for bullet in self.bullets if bullet.frame > 1]
            self.players_lasers = [(laser if laser and laser.frame > 1 else None) for laser in self.players_lasers]
            self.players_bullets = [bullet for bullet in self.players_bullets if bullet.frame > 1]
        EoSDGame.cleanup(self)



def main(path, data, stage_num, rank, character, replay, boss_rush, fps_limit, single_buffer, debug):
    resource_loader = Loader(path)

    try:
        resource_loader.scan_archives(data)
    except IOError:
        sys.stderr.write('Some data files were not found, did you forget the -p option?\n')
        exit(1)

    if stage_num is None:
        story = True
        stage_num = 1
        continues = 3
    else:
        story = False
        continues = 0

    if debug:
        continues = float('inf')

    if replay:
        with open(replay, 'rb') as file:
            replay = T6RP.read(file)
        rank = replay.rank
        character = replay.character

    difficulty = 16
    default_power = [0, 64, 128, 128, 128, 128, 0][stage_num - 1]
    states = [PlayerState(character=character, power=default_power)]

    game_class = EoSDGameBossRush if boss_rush else EoSDGame

    runner = GameRunner(resource_loader, fps_limit=fps_limit, double_buffer=(not single_buffer))
    while True:
        if replay:
            level = replay.levels[stage_num - 1]
            if not level:
                raise Exception

            prng = Random(level.random_seed)

            #TODO: apply the replay to the other players.
            #TODO: see if the stored score is used or if it’s the one from the previous stage.
            if stage_num != 1 and stage_num - 2 in replay.levels:
                previous_level = replay.levels[stage_num - 1]
                states[0].score = previous_level.score
                states[0].effective_score = previous_level.score
            states[0].power = level.power
            states[0].lives = level.lives
            states[0].bombs = level.bombs
            difficulty = level.difficulty
        else:
            prng = None

        # Load stage data
        stage = resource_loader.get_stage('stage%d.std' % stage_num)

        game = game_class(resource_loader, states, stage_num, rank, difficulty, prng=prng, bgms=stage.bgms, continues=continues)

        background_anm_wrapper = resource_loader.get_anm_wrapper(('stg%dbg.anm' % stage_num,))
        background = Background(stage, background_anm_wrapper)

        # Main loop
        runner.load_game(game, background, replay)
        try:
            runner.start()
            break
        except NextStage:
            game.music.pause()
            if not story or stage_num == (7 if boss_rush else 6 if rank > 0 else 5):
                break
            stage_num += 1
            states = [player.state.copy() for player in game.players] # if player.state.lives >= 0]
        except GameOver:
            print('Game over')
            break


pathsep = os.path.pathsep
default_data = (pathsep.join(('CM.DAT', 'th06*_CM.DAT', '*CM.DAT', '*cm.dat')),
                pathsep.join(('ST.DAT', 'th6*ST.DAT', '*ST.DAT', '*st.dat')),
                pathsep.join(('IN.DAT', 'th6*IN.DAT', '*IN.DAT', '*in.dat')),
                pathsep.join(('MD.DAT', 'th6*MD.DAT', '*MD.DAT', '*md.dat')),
                pathsep.join(('102h.exe', '102*.exe', '東方紅魔郷.exe', '*.exe')))


parser = argparse.ArgumentParser(description='Libre reimplementation of the Touhou 6 engine.')

parser.add_argument('data', metavar='DAT', default=default_data, nargs='*', help='Game’s data files')
parser.add_argument('-p', '--path', metavar='DIRECTORY', default='.', help='Game directory path.')
parser.add_argument('-s', '--stage', metavar='STAGE', type=int, default=None, help='Stage, 1 to 7 (Extra).')
parser.add_argument('-r', '--rank', metavar='RANK', type=int, default=0, help='Rank, from 0 (Easy, default) to 3 (Lunatic).')
parser.add_argument('-c', '--character', metavar='CHARACTER', type=int, default=0, help='Select the character to use, from 0 (ReimuA, default) to 3 (MarisaB).')
parser.add_argument('--replay', metavar='REPLAY', help='Select a replay')
parser.add_argument('-b', '--boss-rush', action='store_true', help='Fight only bosses')
parser.add_argument('--single-buffer', action='store_true', help='Disable double buffering')
parser.add_argument('--fps-limit', metavar='FPS', default=60, type=int, help='Set fps limit')
parser.add_argument('--debug', action='store_true', help='Set unlimited continues, and perhaps other debug features.')

args = parser.parse_args()

main(args.path, tuple(args.data), args.stage, args.rank, args.character,
     args.replay, args.boss_rush, args.fps_limit, args.single_buffer,
     args.debug)