Mô đun:Canada NTS

require('strict');																-- alarm when global variables etc are used
local get_args = require ('Mô đun:Arguments').getArgs;							-- simplfy frame and parent frame argument fetching
----------------------------------------------------------------
returns latitude and longitude from wikidata for current page; nil else
Nanaimo BC is Q16461 → latitude: 49.164166666667; longitude: -123.93638888889
TODO: accept a  argument? if called with  fetch lat/lon for that qid and not for current page
local function wikidata_lat_lon_get()
	local qid = mw.wikibase.getEntityIdForCurrentPage();						-- get the qid for the current page
	if qid then
		local value_t = mw.wikibase.getBestStatements (qid, 'P625')1;			-- attempt to get P625; nil when article does not have P625
		if value_t then
			value_t = value_t.mainsnak.datavalue.value;							--point to the value table
			return value_t.latitude, value_t.longitude;							-- return coordinates from value_t
		end
	end
end
--------------------------------------------------------
returns local article name for this wiki using ; nil else
TODO: if no local article fallback to en.wiki
local function article_name_from_qid_get (qid)
	local this_wiki_code = mw.language.getContentLanguage():getCode();			-- get this wiki's language code
	if 'wikidata' == mw.site.server then
		this_wiki_code = mw.getCurrentFrame():callParserFunction('int', {'lang'}); -- on Wikidata so use interface language setting instead
	end
	local wd_article = mw.wikibase.getSitelink (qid, this_wiki_code .. 'wiki');	-- fetch article title from WD; nil when no title available at this wiki
	if wd_article then
		wd_article = table.concat ({':', this_wiki_code, ':', wd_article});		-- interwiki-style link without brackets if taken from WD; leading colon required
	end
	return wd_article;															-- article title from WD; nil else
end
------------------------------------------------------------------------------------------------
This function takes in a National Tiling System ID and outputs the name of the National Topographic System map
sheet with that ID.  If no map sheet has been published under that ID, the output will be blank.
local function _name (args_t)
	local data_t = mw.loadData ('Mô đun:Canada NTS/data');						-- load the ~/data module
	
	if not data_targs_t1 then												-- nil when NTS ID not listed in ~/data
		return "";
	elseif  == data_targs_t1 then											-- when sheet has no title
		return '(untitled)';													-- return a place-holder; lowercase here because capitalized implies that 'Untitled' is the 'title'
	end
	local title_parts_t = mw.text.split (data_targs_t1, '|');				-- title_parts1 is link part of a wikilink; title_parts2 is wikilink label (map name) or nil
	if mw.title.getCurrentTitle().text == title_parts_t1 then					-- don't create wikilink to the current article
		return title_parts_t2 or title_parts_t1;							-- return plaintext wikilink label or plain text article title (wikilink)
	end
	return string.format ('%s', data_targs_t1);							-- return wikilinked map title
end
--------------------------------------------------------------------------------------------------
external invoke interface
This function takes in a National Tiling System ID and outputs the name of the National Topographic System map sheet with that ID.
If no map sheet has been published under that ID, the output will be blank.
local function name (frame)
	local args_t = get_args (frame);
	if not args_t1 then
		return 'National Tiling System ID required';	-- TODO: better, more informative error handling
	end
	
	return _name (args_t);
end
------------------------------------------------------------------------------
a sequence of sequences.  Each sequence in  has two coordinate sequences that defines a rectangle
identified by the northwest and southeast corners of a subsection in the NTS series map.  The first coordinate sequence identifies the northwest
corner of the subsection; the second sequence identifies the southwest corner of the subsection.
local coord_limits_t = {
	,														-- series: 40, 30, 20, 10
	,														-- series: 41, 31, 21, 11, 1
	,														-- series: 102, 92, ..., 2; 103, 93, ..., 3
	,														-- series: 114, 104, ..., 14; 115, 105, ..., 15; 116, 106, ..., 16
	,														-- series: 117, 107, ..., 27
	,														-- series: 98, 88, ..., 38
	,														-- series: 99, 89, ..., 29
	,														-- series: 560, 340, 120
	}
--------------------------------------------------------------------------
validates  and  to be inside one of the rectangles defined in 
returns true when in bounds; false else
local function lat_lon_validate (lat, lon)
	for _, coord_limit_t in ipairs (coord_limits_t) do							-- loop through the rectangle sequences in 
		local lat_N = coord_limit_t11;										-- for readability ...
		local lat_S = coord_limit_t21;
		local lon_W = coord_limit_t12;
		local lon_E = coord_limit_t22;
		if (lat >= lat_S) and (lat = lon_E) and (lon  and  locate a point within bounds so done
		end
	end
	
	return false;																--  and  locate a point out of bounds so done
end
--------------------------------------------------------------------------------------------
Calculates bounding boxes for 1:50,000 and 1:250,000 scale map sheets/areas from latitude and longitude
local function extents (lat, lon)
	local belt = math.floor((lat - 40) * 4);
	local strip = math.floor((lon - 48) * 2);
	local s, n, e, w															-- 1:50,000 scale bounding box
	local a_s, a_n, a_e, a_w													-- 1:250,000 scale bounding box
	local lat_limits = -- Latitude limits of bounding box
		{ s = belt / 4 + 40,
		n = belt / 4 + 40.25,
		a_s = math.floor(lat),
		a_n = math.floor(lat + 1)
		}
	local lon_limits = {e, w, a_e, a_w}
																				-- Calculation of longitude limits is different depending on zone
	if lat >= 40 and lat = 68 and lat = 80 and lat --------------------------------
calculates NTS identifier from latitude and longitude.  If  and  not supplied, attempts to fetch
coordinates from wikidata
when successful, returns NTS identifier; nil else
local function nts_id_from_lat_long_get (lat, lon)
	if not (lat and lon) then													-- nil when missing, empty, or not a number
		lat, lon = wikidata_lat_lon_get();										-- / template param(s) invalid or missing; attempt to get / from wikidata
	end
																				-- wikidata uses negative numbers for west (and south) so must account for that
	if lat then																	-- normalize coords; assumes that given coords are intended to be on canada nts map
		if 0 > lat then
			lat = lat * -1.0;													-- required because wikidata coords are signed
		end
		if 0 > lon then
			lon = lon * -1.0;													-- required because wikidata coords are signed
		end
	else
		return nil;
	end
	
	if not lat_lon_validate (lat, lon) then
		return nil;																-- / out of bounds; TODO: better error handling/messaging
	end
	local series, numarea, area, sheet_inter, sheet
	if lat >= 40 and lat = 68 and lat = 80 and lat = 56 and lon = 84 then series = 121 else series = 120 end				-- These are correct - Go to , select "Overlay reference layers", then "National Tiling System grid coverage"
		elseif lon >= 72 and lon = 84 then series = 341 else series = 340 end
		elseif lon >= 88 and lon = 84 then series = 561 else series = 560 end
		elseif lon >= 104 and lon , select "Overlay reference layers", then "National Tiling System grid coverage"
			if lat >= 84 then series = 781 else series = 780 end				-- 780, 781, 910, or 911
		elseif lon >= 120 and lon = 84 then series = 911 else series = 910 end
		end -- Remember the difference between the National Topographic System and the National Tiling System
		
		numarea = (math.floor(lat % 4) * 10) + (math.floor((lon / 8) + 1) % 2)	-- Calculate 1:250,000 map area ID
		local high_arctic_zone_t = {0='A', 1='B', 11='C', 10='D', 20='E', 21='F', 31='G', 30='H'};
		area = high_arctic_zone_tnumarea;										-- translate
		sheet_inter = math.floor((lat % 1) * 4) * 10 + math.floor((lon % 8) / 2)	-- Calculate 1:50,000 map sheet ID
	end
	local sheet_t = {0=1, 1=2, 2=3, 3=4, 13=5, 12=6, 11=7, 10=8, 20=9, 21=10, 22=11, 23=12, 33=13, 32=14, 31=15, 30=16}
	sheet = sheet_tsheet_inter
	return series, area, sheet
end
--------------------------------------------------------------------
return  as a number when valid and in-bounds; nil else
– must be a map series number as enumerated in File:NTS Zones and Map Series Numbers.png; leading zeros allowed
local function nts_series_validate (series)
	series = (series and tonumber (series));									-- convert series to a number
	if not series then
		return nil;																-- something other than a number; declare failure and abandon
	end
	local series_limits_t = 
	for _, limits_t in ipairs (series_limits_t) do								-- loop through the series limits
		if (series >= limits_t1) and (series --------------------------------------------
return  when valid and in-bounds; nil else
– must be a single uppercase letter; when  identifies a map series in the 
	High Arctic and Arctic zones: A-H
	Southern zone: A-P
local function nts_area_validate (series, area)
	local is_northern;															-- a flag
	
	local northern_series_t = 
	for _, limits_t in ipairs (northern_series_t) do
		if (series >= limits_t1) and (series ------------------------------------------
return  when valid and in-bounds; nil else
– optional; if present must be a number: 1-16; leading zeros allowed
local function nts_sheet_validate (sheet)
	sheet = (sheet and tonumber (sheet)) or nil;								-- sheet as a number; or if not a number or not present, nil
	
	if not sheet then
		return nil;																-- something other than a number; declare failure and abandon
	end
	if (1 > sheet) or (16 --------------------------------------------
Calculates bounding boxes of 1:50,000 and 1:250,000 scale map sheets/areas from map sheet ID
is 1:1,000,000 scale map series – a 1-to-three digit number
is 1:250,000 scale map area – an uppercase letter A-P
is 1:50,000 scale map sheet – a number 1–16
local function extents_from_grid (series, area, sheet)
	local belt                                                                  -- 192 belts between 40°N and 88°N, each 0.25° of latitude in breadth
	local belt_area_south = {"A"=0, "B"=0, "C"=0, "D"=0, "E"=4, "F"=4, "G"=4, "H"=4, "I"=8, "J"=8, "K"=8, "L"=8, "M"=12, "N"=12, "O"=12, "P"=12}
	local belt_area_north = {"A"=0, "B"=0, "C"=4, "D"=4, "E"=8, "F"=8, "G"=12, "H"=12}
	local belt_sheet = {1=0, 2=0, 3=0, 4=0, 5=1, 6=1, 7=1, 8=1, 9=2, 10=2, 11=2, 12=2, 13=3, 14=3, 15=3, 16=3}
	if series >= 120 then
		belt = 160 + series % 10 * 16 + (belt_area_northarea or 0) + (belt_sheetsheet or 0)
	elseif series = 112 then
		belt = series % 10 * 16 + (belt_area_northarea or 0) + (belt_sheetsheet or 0)
	else
		belt = series % 10 * 16 + (belt_area_southarea or 0) + (belt_sheetsheet or 0)
	end
	local strip																	-- 192 strips between 48°W and 144°W, each 0.5° of longitude in breadth
	local strip_series_high_arctic = {12=16, 34=48, 56=80, 78=112, 91=144}
	local strip_area_southern = {"A"=0, "B"=4, "C"=8, "D"=12, "E"=12, "F"=8, "G"=4, "H"=0, "I"=0, "J"=4, "K"=8, "L"=12, "M"=12, "N"=8, "O"=4, "P"=0}
	local strip_area_arctic = {"A"=0, "B"=8, "C"=8, "D"=0, "E"=0, "F"=8, "G"=8, "H"=0}
	local strip_area_high_arctic = {"A"=0, "B"=16, "C"=16, "D"=0, "E"=0, "F"=16, "G"=16, "H"=0}
	local strip_sheet_southern = {1=0, 2=1, 3=2, 4=3, 5=3, 6=2, 7=1, 8=0, 9=0, 10=1, 11=2, 12=3, 13=3, 14=2, 15=1, 16=0}
	local strip_sheet_arctic = {1=0, 2=2, 3=4, 4=6, 5=6, 6=4, 7=2, 8=0, 9=0, 10=2, 11=4, 12=6, 13=6, 14=4, 15=2, 16=0}
	local strip_sheet_high_arctic = {1=0, 2=4, 3=8, 4=12, 5=12, 6=8, 7=4, 8=0, 9=0, 10=4, 11=8, 12=12, 13=12, 14=8, 15=4, 16=0}
	local east_limit, west_limit;												-- For 1:50,000 scale map sheet
	local area_east_limit, area_west_limit;										-- For 1:250,000 scale map area
	if series >= 120 then														-- High Arctic zone
		strip = strip_series_high_arcticmath.floor(series / 10) + (strip_area_high_arcticarea or 0) + (strip_sheet_high_arcticsheet or 0);
		east_limit = strip * 0.5 + 48
		west_limit = (strip + 4) * 0.5 + 48
		area_east_limit = math.floor(strip / 16) * 8 + 48
		area_west_limit = math.floor((strip + 16) / 16) * 8 + 48
	elseif series = 7 then					-- Arctic zone
		strip = math.floor(series / 10) * 16 + (strip_area_arcticarea or 0) + (strip_sheet_arcticsheet or 0);
		east_limit = strip * 0.5 + 48
		west_limit = (strip + 2) * 0.5 + 48
		area_east_limit = math.floor(strip / 8) * 4 + 48
		area_west_limit = math.floor((strip + 8) / 8) * 4 + 48
	else																		-- Southern zone
		strip = math.floor(series / 10) * 16 + (strip_area_southernarea or 0) + (strip_sheet_southernsheet or 0);
		east_limit = strip * 0.5 + 48
		west_limit = (strip + 1) * 0.5 + 48
		area_east_limit = math.floor(strip / 4) * 2 + 48
		area_west_limit = math.floor((strip + 4) / 4) * 2 + 48
	end
	
	local grid_limits = {
		"south" = belt * 0.25 + 40,
		"north" = belt * 0.25 + 40.25,
		"area_south" = math.floor(belt / 4) + 40,
		"area_north" = math.floor(belt / 4) + 41,
		"east" = east_limit,
		"west" = west_limit,
		"area_east" = area_east_limit,
		"area_west" = area_west_limit
		}
	
	return grid_limits
end
--name= to append the map name (from Module:Canada_NTS/data) to the output
local function grid (frame)
	local args_t = get_args (frame);											-- fetch frame and parent frame parameters into a single table
	local lat, lon = tonumber(args_t.lat), tonumber(args_t.lon);
																				-- flags to control what the output looks like
	local print_area = 'yes' == args_t.area;									-- when true, render only the 'area' portion '30M' instead of sheet '30M11'
	local print_link = 'yes' == args_t.link;									-- when true, format the area or sheet output as an external link
	local print_name = 'yes' == args_t.name;									-- when true, append map name from ~/data
	local series, area, sheet;
	for k, v in ipairs (args_t) do
		if 1 == k then															-- args_t1 to series; must be a one-to-three digit number
			series = nts_series_validate (args_t1);
			if not series then
				return 'invalid NTS series input';
			end
			lat = nil;															-- unset these if present because we won't be using them when we have nts id (which may or may not be good)
			lon = nil;
		elseif 2 == k then														-- args_t2 to area; must one uppercase letter A-P
			area = nts_area_validate (series, args_t2);
			if not area then
				return 'invalid NTS area input';
			end
		elseif 3 == k then														-- args_t3 to sheet; must be a number 1-16
			sheet = nts_sheet_validate (args_t3);
			if not sheet then
				return 'invalid NTS sheet input';
			end
		end
	end
	if series and not sheet then												-- if we have nts id without sheet (an area-only)
		print_area = true;														-- set this so that later we create the correct output
	end
	
	if not series or not area then
		series, area, sheet = nts_id_from_lat_long_get (lat, lon);
		if not series then
			return 'lat/long input fail';		-- TODO: better, more informative error handling
		end
	end
	local output = print_area and (series .. area) or (series .. area .. sheet);
	print_name = print_name and (' ' .. _name ({output})) or ;				-- reuse  to hold name or empty string
	local extents_t = {};														-- to hold bounding box coordinates for url
	if print_link and lat then													-- when we have lat/lon
		extents_t = extents (lat, lon);											-- get a table of sheet and area extents from lat/lon
	elseif print_link then														-- when we have nts id
		extents_t = extents_from_grid (series, area, sheet);					-- get a table of sheet and area extents from nts id parts
		if extents_t == nil then
			return 'NTS identifier input fail';	-- TODO: better, more informative error handling
		end
	else
		print_link = nil;														-- unset because we can't create a link
	end
	if print_link then
		local ext_link_fmt_str = ' %s';
		output = print_area and string.format (ext_link_fmt_str, extents_t.area_west, extents_t.area_south, extents_t.area_east, extents_t.area_north, output, output) or
					string.format (ext_link_fmt_str, extents_t.west, extents_t.south, extents_t.east, extents_t.north, output, output);
	end
	output = output .. print_name;												-- append name or empty string
	return output;																-- and done
end
------------------------------------------------------------------------------------
local function doc_support (frame)
	local args_t = get_args (frame);											-- fetch frame and parent frame parameters into a single table
	local data = mw.loadData ('Mô đun:Canada NTS/data');						-- load the ~/data module
	local lang_obj = mw.language.getContentLanguage();							-- get language object for number formatting
	local count = 0;															-- a generic counter 
	local area_count = 0;														-- counter for area maps (1:250,000)
	local sheet_count = 0;														-- counter for sheet maps (1:50,000)
	
	if 'count' == args_t1 then												-- count the number of entries in ~/data
		for k, _ in pairs (data) do												-- don't care about key and value
			if k:match ('A-P$') then
				area_count = area_count + 1;									-- bump the counter
			else
				sheet_count = sheet_count + 1;									-- bump the counter
			end
		end
		return string.format ('%s (1:250,000: %s; 1:50,000: %s)', lang_obj:formatNum (sheet_count + area_count), lang_obj:formatNum (area_count), lang_obj:formatNum (sheet_count));
		
	elseif 'untitled' == args_t1 then											-- count the number of entries in ~/data that do not have a NTS title
		for _, v in pairs (data) do												-- don't care about key
			if  == v then														-- when value is empty string, no title so
				count = count + 1;												-- bump the counter
			end
		end
	end
	return lang_obj:formatNum(count);											-- make all pretty-like and done
end
----------------------------------------------------------------------
return {
	grid = grid,																-- entry points from invokes
	name = name,
	doc_support = doc_support,
	
	extents_from_grid = extents_from_grid,										-- entry points when this module is require()d into other modules
	nts_series_validate = nts_series_validate,
	nts_area_validate = nts_area_validate,
	nts_sheet_validate = nts_sheet_validate,
	}