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.Datastructures.Scheme;

import org.hedgewars.hedgeroid.Datastructures.Weaponset;

import org.hedgewars.hedgeroid.frontlib.Frontlib;

import android.content.Context;

import android.graphics.drawable.Drawable;

import android.os.Bundle;

import android.os.Handler;

import android.os.Looper;

import android.os.Message;

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;

public class MapFragment extends Fragment implements RoomStateManager.Observer {

	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();

		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();

		}

		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.registerObserver(this);

		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();

		stateManager.unregisterObserver(this);

	}

	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());

				mapNameSpinner.setSelection(random.nextInt(mapNameSpinner.getCount()));

			}

		}

	};

	public void onChiefStatusChanged(boolean isChief) {

		setChiefState(isChief);

	}

	public void onMapChanged(MapRecipe recipe) {

		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;

	}

	public void onGameStyleChanged(String gameStyle) { }

	public void onSchemeChanged(Scheme scheme) { }

	public void onWeaponsetChanged(Weaponset weaponset) { }

	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;

			}

		}

	};

	/**

	 * This class allows you to define a runnable that is called when there has been no activity

	 * for a set amount of time, where activity is determined by calls to the activity() method

	 * of the handler. It is used here to update the map preview when there have been no updates

	 * to the relevant map information for a time, to prevent triggering several updates at once

	 * when different parts of the information change.

	 */

	private static final class CalmDownHandler extends Handler {

		int runningMessagesCounter = 0;

		final Runnable inactivityRunnable;

		final long inactivityMs;

		boolean stopped;

		public CalmDownHandler(Looper looper, Runnable runnable, long inactivityMs) {

			super(looper);

			this.inactivityRunnable = runnable;

			this.inactivityMs = inactivityMs;

		}

		public void activity() {

			runningMessagesCounter++;

			sendMessageDelayed(obtainMessage(), inactivityMs);

		}

		@Override

		public void handleMessage(Message msg) {

			runningMessagesCounter--;

			if(runningMessagesCounter==0 && !stopped) {

				inactivityRunnable.run();

			}

		}

		public void stop() {

			stopped = true;

		}

	}

}