/*

 * 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;

            }

        }

    };

}