/*
 * Hedgewars for Android. An Android port of Hedgewars, a free turn based strategy game
 * Copyright (C) 2012 Simeon Maxein <smaxein@googlemail.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; either version 2
 * of the License, or (at your option) any later version.
 *
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */

package org.hedgewars.hedgeroid;

import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Random;

import org.hedgewars.hedgeroid.R;
import org.hedgewars.hedgeroid.Datastructures.FrontendDataUtils;
import org.hedgewars.hedgeroid.Datastructures.MapFile;
import org.hedgewars.hedgeroid.Datastructures.MapRecipe;
import org.hedgewars.hedgeroid.frontlib.Frontlib;
import org.hedgewars.hedgeroid.util.CalmDownHandler;

import android.content.Context;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemSelectedListener;
import android.widget.ArrayAdapter;
import android.widget.ImageView;
import android.widget.Spinner;
import android.widget.TableRow;
import android.widget.Toast;

/**
 * Display a map preview, and configuration options for the map.
 *
 * Mostly for layout reasons, this does not include the theme setting, which
 * (arguably) is more a map setting than a general game setting.
 */
public class MapFragment extends Fragment {
    private Spinner mapTypeSpinner, mapNameSpinner, templateSpinner, mazeSizeSpinner;
    private TableRow nameRow, templateRow, mazeSizeRow;
    private ImageView mapPreview;

    private List<MapFile> mapFiles;
    private RoomStateManager stateManager;
    private Random random = new Random();
    private CalmDownHandler mapPreviewHandler;

    /*
     * Rendering the preview can take a few seconds on Android, so we want to prevent preview
     * requests from queueing up if maps are changed quickly. So if there is already a preview
     * being generated, we store our latest request in the newPreviewRequest variable instead.
     * Once the current preview is finished generating it will start on that one.
     */
    private boolean previewGenerationInProgress;
    private MapRecipe newPreviewRequest;
    private MapRecipe currentMap; // kept for reference on every change to find out what changed

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        View v = inflater.inflate(R.layout.fragment_map, container, false);
        final Context appContext = getActivity().getApplicationContext();

        /*
         * This handler will start the map preview after none of the map settings
         * have been updated for a short time.
         */
        mapPreviewHandler = new CalmDownHandler(getActivity().getMainLooper(), new Runnable() {
            public void run() {
                if(!previewGenerationInProgress) {
                    mapPreview.setImageResource(R.drawable.roomlist_preparing);
                    MapPreviewGenerator.startPreviewGeneration(appContext, stateManager.getMapRecipe(), mapPreviewListener);
                    previewGenerationInProgress = true;
                } else {
                    newPreviewRequest = stateManager.getMapRecipe();
                }
            }
        }, 250);

        nameRow = (TableRow) v.findViewById(R.id.rowMapName);
        templateRow = (TableRow) v.findViewById(R.id.rowTemplateFilter);
        mazeSizeRow = (TableRow) v.findViewById(R.id.rowMazeSize);
        mapPreview = (ImageView) v.findViewById(R.id.mapPreview);
        mapPreview.setImageDrawable(null);;
        mapPreview.setOnClickListener(mapClickListener);

        try {
            mapFiles = FrontendDataUtils.getMaps(getActivity());
        } catch (IOException e) {
            Toast.makeText(getActivity().getApplicationContext(), R.string.error_missing_sdcard_or_files, Toast.LENGTH_LONG).show();
            getActivity().finish();
            return null;
        }
        Collections.sort(mapFiles, MapFile.MISSIONS_FIRST_NAME_ORDER);

        List<String> mapNames = MapFile.toDisplayNameList(mapFiles, getResources());
        mapTypeSpinner = prepareSpinner(v, R.id.spinMapType, Arrays.asList(getResources().getStringArray(R.array.map_types)), mapTypeSelectedListener);
        mapNameSpinner = prepareSpinner(v, R.id.spinMapName, mapNames, mapNameSelectedListener);
        templateSpinner = prepareSpinner(v, R.id.spinTemplateFilter, Arrays.asList(getResources().getStringArray(R.array.map_templates)), mapTemplateSelectedListener);
        mazeSizeSpinner = prepareSpinner(v, R.id.spinMazeSize, Arrays.asList(getResources().getStringArray(R.array.map_maze_sizes)), mazeSizeSelectedListener);

        stateManager.addListener(roomStateChangeListener);
        currentMap = stateManager.getMapRecipe();
        if(currentMap != null) {
            updateDisplay(currentMap);
        }
        setChiefState(stateManager.getChiefStatus());
        mapPreviewHandler.activity();
        return v;
    }

    private static Spinner prepareSpinner(View v, int id, List<String> items, OnItemSelectedListener itemSelectedListener) {
        Spinner spinner = (Spinner)v.findViewById(id);
        ArrayAdapter<String> adapter = new ArrayAdapter<String>(v.getContext(), R.layout.listview_item, items);
        adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
        spinner.setAdapter(adapter);
        spinner.setOnItemSelectedListener(itemSelectedListener);
        return spinner;
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        try {
            stateManager = ((RoomStateManager.Provider)getActivity()).getRoomStateManager();
        } catch(ClassCastException e) {
            throw new RuntimeException("Hosting activity must implement RoomStateManager.Provider.", e);
        }
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        mapPreviewHandler.stop();
        newPreviewRequest = null;

        stateManager.removeListener(roomStateChangeListener);
    }

    private void setChiefState(boolean chiefState) {
        mapTypeSpinner.setEnabled(chiefState);
        mapNameSpinner.setEnabled(chiefState);
        templateSpinner.setEnabled(chiefState);
        mazeSizeSpinner.setEnabled(chiefState);
        mapPreview.setEnabled(chiefState);

        if(chiefState) {
            sendMapnameAndGenerator();
            stateManager.changeMapTemplate(templateSpinner.getSelectedItemPosition());
            stateManager.changeMazeSize(mazeSizeSpinner.getSelectedItemPosition());
        }
    }

    private void updateDisplay(MapRecipe map) {
        nameRow.setVisibility(map.mapgen == Frontlib.MAPGEN_NAMED ? View.VISIBLE : View.GONE);
        templateRow.setVisibility(map.mapgen == Frontlib.MAPGEN_REGULAR ? View.VISIBLE : View.GONE);
        mazeSizeRow.setVisibility(map.mapgen == Frontlib.MAPGEN_MAZE ? View.VISIBLE : View.GONE);

        mapTypeSpinner.setSelection(map.mapgen);
        int mapPosition = findMapPosition(mapFiles, map.name);
        if(mapPosition >= 0) {
            mapNameSpinner.setSelection(mapPosition);
        }
        templateSpinner.setSelection(map.templateFilter);
        mazeSizeSpinner.setSelection(map.mazeSize);
    }

    private static int findMapPosition(List<MapFile> mapFiles, String mapName) {
        for(int i=0; i<mapFiles.size(); i++) {
            if(mapName.equals(mapFiles.get(i).name)) {
                return i;
            }
        }
        return -1;
    }

    private void sendMapnameAndGenerator() {
        int mapType = mapTypeSpinner.getSelectedItemPosition();
        String mapName = mapFiles.get(mapNameSpinner.getSelectedItemPosition()).name;
        stateManager.changeMapNameAndGenerator(MapRecipe.mapnameForGenerator(mapType, mapName));
    }

    private final OnItemSelectedListener mapTypeSelectedListener = new OnItemSelectedListener() {
        public void onItemSelected(AdapterView<?> adapter, View v, int position, long arg3) {
            sendMapnameAndGenerator();
        }
        public void onNothingSelected(AdapterView<?> arg0) {}
    };

    private final OnItemSelectedListener mapNameSelectedListener = new OnItemSelectedListener() {
        public void onItemSelected(AdapterView<?> adapter, View v, int position, long arg3) {
            sendMapnameAndGenerator();
        }
        public void onNothingSelected(AdapterView<?> arg0) {}
    };

    private final OnItemSelectedListener mapTemplateSelectedListener = new OnItemSelectedListener() {
        public void onItemSelected(AdapterView<?> adapter, View v, int position, long arg3) {
            stateManager.changeMapTemplate(position);
        }
        public void onNothingSelected(AdapterView<?> arg0) {}
    };

    private final OnItemSelectedListener mazeSizeSelectedListener = new OnItemSelectedListener() {
        public void onItemSelected(AdapterView<?> adapter, View v, int position, long arg3) {
            stateManager.changeMazeSize(position);
        }
        public void onNothingSelected(AdapterView<?> arg0) {}
    };

    private final OnClickListener mapClickListener = new OnClickListener() {
        public void onClick(View v) {
            stateManager.changeMapSeed(MapRecipe.makeRandomSeed());
            if(mapTypeSpinner.getSelectedItemPosition() == Frontlib.MAPGEN_NAMED) {
                mapNameSpinner.setSelection(random.nextInt(mapNameSpinner.getCount()));
            }
        }
    };

    private final RoomStateManager.Listener roomStateChangeListener = new RoomStateManager.ListenerAdapter() {
        @Override
        public void onChiefStatusChanged(boolean isChief) {
            setChiefState(isChief);
        };

        @Override
        public void onMapChanged(MapRecipe recipe) {
            // Only trigger a preview update if a relevant field changed (not theme)
            if(currentMap==null
                    || currentMap.mapgen != recipe.mapgen
                    || currentMap.mazeSize != recipe.mazeSize
                    || !currentMap.name.equals(recipe.name)
                    || !currentMap.seed.equals(recipe.seed)
                    || currentMap.templateFilter != recipe.templateFilter
                    || !Arrays.equals(currentMap.getDrawData(), recipe.getDrawData())) {
                mapPreviewHandler.activity();
            }
            updateDisplay(recipe);
            currentMap = recipe;
        };
    };

    private MapPreviewGenerator.Listener mapPreviewListener = new MapPreviewGenerator.Listener() {
        public void onMapPreviewResult(Drawable preview) {
            if(newPreviewRequest != null) {
                MapPreviewGenerator.startPreviewGeneration(getActivity().getApplicationContext(), newPreviewRequest, mapPreviewListener);
                newPreviewRequest = null;
            } else {
                if(mapPreview != null) {
                    mapPreview.setImageDrawable(preview);
                }
                previewGenerationInProgress = false;
            }
        }
    };
}