using Invercargill.Mapping;

namespace Usm {

    public class Paths {

        public string destination { get; set; }
        public string prefix { get; set; }

        public string bin { get; set; }
        public string include { get; set; }
        public string data { get; set; }
        public string info { get; set; }
        public string lib { get; set; }
        public string canonlib { get; set; }
        public string man { get; set; }
        public string libexec { get; set; }
        public string locale { get; set; }
        public string local_state { get; set;}
        public string sbin { get; set; }
        public string shared_state { get; set; }
        public string sys_config { get; set; }
        public string tags { get; set; }

        public string usm_config_dir { get; set; }

        public void set_envs() {
            Environment.set_variable("DESTDIR", Paths.ensure_trailing_slash(destination), true);
            Environment.set_variable("PREFIX", Paths.ensure_trailing_slash(prefix), true);
            Environment.set_variable("BINDIR", add_prefix(bin), true);
            Environment.set_variable("INCLUDEDIR", add_prefix(include), true);
            Environment.set_variable("DATADIR", add_prefix(data), true);
            Environment.set_variable("INFODIR", add_prefix(info), true);
            Environment.set_variable("LIBDIR", add_prefix(lib), true);
            Environment.set_variable("CANONLIBDIR", add_prefix(canonlib), true);
            Environment.set_variable("MANDIR", add_prefix(man), true);
            Environment.set_variable("LIBEXECDIR", add_prefix(libexec), true);
            Environment.set_variable("LOCALEDIR", add_prefix(locale), true);
            Environment.set_variable("LOCALSTATEDIR", Paths.ensure_trailing_slash(local_state), true);
            Environment.set_variable("SBINDIR", add_prefix(sbin), true);
            Environment.set_variable("SHAREDSTATEDIR", Paths.ensure_trailing_slash(shared_state), true);
            Environment.set_variable("SYSCONFIGDIR", Paths.ensure_trailing_slash(sys_config), true);
            Environment.set_variable("TAGSDIR", add_prefix(tags), true);
        }

        public static string ensure_trailing_slash(string path) {
            if (path == null || path.length == 0) {
                return "/";
            }
            return path.has_suffix("/") ? path : path + "/";
        }

        public string add_prefix(string path) {
            return ensure_trailing_slash(Path.build_filename(prefix, path));
        }

        public string get_suggested_base_path_for_type(ResourceType type) {
            switch (type) {
                case ResourceType.ROOT_PATH:
                    return destination;
                case ResourceType.PATH:
                    return Path.build_filename(destination, prefix);
                case ResourceType.OPTIONAL:
                    return Path.build_filename(destination, "opt");
                case Usm.ResourceType.RESOURCE:
                    return Path.build_filename(destination, prefix, data);
                case ResourceType.CONFIGURATION:
                    return Path.build_filename(destination, sys_config);
                case Usm.ResourceType.BINARY:
                    return Path.build_filename(destination, prefix, bin);
                case Usm.ResourceType.SUPER_BINARY:
                    return Path.build_filename(destination, prefix, sbin);
                case Usm.ResourceType.LIBRARY:
                case Usm.ResourceType.LIBRARY_RESOURCE:
                    return Path.build_filename(destination, prefix, lib);
                case Usm.ResourceType.LIBRARY_EXECUTABLE:
                    return Path.build_filename(destination, prefix, libexec);
                case Usm.ResourceType.CANONICAL_LIBRARY:
                case Usm.ResourceType.CANONICAL_LIBRARY_RESOURCE:
                    return Path.build_filename(destination, prefix, canonlib);
                case Usm.ResourceType.INFO_PAGE:
                    return Path.build_filename(destination, prefix, info);
                case Usm.ResourceType.MANUAL_PAGE:
                    return Path.build_filename(destination, prefix, man);
                case Usm.ResourceType.LOCALE:
                    return Path.build_filename(destination, prefix, locale);
                case Usm.ResourceType.APPLICATION:
                    return Path.build_filename(destination, prefix, "share", "applications");
                case Usm.ResourceType.INCLUDE:
                    return Path.build_filename(destination, prefix, include);
                case Usm.ResourceType.PKG_CONFIG:
                    return Path.build_filename(destination, prefix, lib, "pkgconfig");
                case Usm.ResourceType.VALA_API:
                    return Path.build_filename(destination, prefix, "share", "vala", "vapi");
                case Usm.ResourceType.GOBJECT_IR:
                    return Path.build_filename(destination, prefix, "share", "gir-1.0");
                case Usm.ResourceType.TYPELIB:
                    return Path.build_filename(destination, prefix, lib, "girepository-1.0");
                case Usm.ResourceType.GIO_MODULE:
                    return Path.build_filename(destination, prefix, lib, "gio", "modules");
                case Usm.ResourceType.TAG:
                    return Path.build_filename(destination, prefix, tags);
                default:
                    assert_not_reached();
            }
        }

        public string get_suggested_path_for_resource(ResourceRef resource) {
            if (resource.resource_type == ResourceType.TAG) {
                return get_tag_file_path(resource.resource);
            }
            return Path.build_filename(get_suggested_base_path_for_type(resource.resource_type), resource.resource);
        }


        public string get_tag_file_path(string tag) {
            var tag_path = tag.replace(".", "/");
            tag_path += ".tag";

            return Path.build_filename(destination, prefix, tags, tag_path);
        }

        public string get_tag_dir_path(string tag) {
            var tag_path = tag.replace(".", "/");
            return Path.build_filename(destination, prefix, tags, tag_path);
        }

        public Paths.defaults() {
            destination = "/";
            prefix = "/usr";
            bin = "bin";
            include = "include";
            data = "share";
            info = "share/info";
            lib = "lib";
            canonlib = "lib";
            man = "share/man";
            libexec = "libexec";
            locale = "share/locale";
            local_state = "var";
            sbin = "sbin";
            shared_state = "com";
            sys_config = "etc";
            tags = "share/usm-tags";

            usm_config_dir = "/etc/usm";
        }

        public Paths.usm_environ(Paths? defaults = null) {
            var fallback = defaults ?? new Paths.defaults();
            override_from_environment(fallback);
        }

        private Paths.empty() {}

        public Paths() {
            var provisional_paths = new Paths.usm_environ();
            try {
                var config = new Configuration.from_paths(provisional_paths);
                override_from_environment(config.paths);
            }
            catch {
                override_from_environment(provisional_paths);
            }
        }

        public Paths clone() {
            return new Paths() {
                destination = destination,
                prefix = prefix,
                bin = bin,
                include = include,
                data = data,
                info = info,
                lib = lib,
                canonlib = canonlib,
                man = man,
                libexec = libexec,
                locale = locale,
                local_state = local_state,
                sbin = sbin,
                shared_state = shared_state,
                sys_config = sys_config,
                tags = tags,
                usm_config_dir = usm_config_dir,
            };
        }

        private void override_from_environment(Paths fallback) {
            destination = Environment.get_variable("USM_DESTDIR") ?? fallback.destination;
            prefix = Environment.get_variable("USM_PREFIX") ?? fallback.prefix;
            bin = Environment.get_variable("USM_BINDIR") ?? fallback.bin;
            include = Environment.get_variable("USM_INCLUDEDIR") ?? fallback.include;
            data = Environment.get_variable("USM_DATADIR") ?? fallback.data;
            info = Environment.get_variable("USM_INFODIR") ?? fallback.info;
            lib = Environment.get_variable("USM_LIBDIR") ?? fallback.lib;
            canonlib = Environment.get_variable("USM_CANONLIBDIR") ?? fallback.canonlib;
            man = Environment.get_variable("USM_MANDIR") ?? fallback.man;
            libexec = Environment.get_variable("USM_LIBEXECDIR") ?? fallback.libexec;
            locale = Environment.get_variable("USM_LOCALEDIR") ?? fallback.locale;
            local_state = Environment.get_variable("USM_LOCALSTATEDIR") ?? fallback.local_state;
            sbin = Environment.get_variable("USM_SBINDIR") ?? fallback.sbin;
            shared_state = Environment.get_variable("USM_SHAREDSTATEDIR") ?? fallback.shared_state;
            sys_config = Environment.get_variable("USM_SYSCONFIGDIR") ?? fallback.sys_config;
            tags = Environment.get_variable("USM_TAGSDIR") ?? fallback.tags;
            usm_config_dir = Environment.get_variable("USM_CONFIGDIR") ?? fallback.usm_config_dir;
        }

        public static PropertyMapper<Paths> get_mapper() {
            return new PropertyMapperBuilder<Paths>()
                .map<string?>("prefix", o => o.prefix, (o, v) => o.prefix = v)
                    .when_undefined(o => o.prefix = o.prefix)
                .map<string?>("bin", o => o.bin, (o, v) => o.bin = v)
                    .when_undefined(o => o.bin = o.bin)
                .map<string?>("include", o => o.include, (o, v) => o.include = v)
                    .when_undefined(o => o.include = o.include)
                .map<string?>("data", o => o.data, (o, v) => o.data = v)
                    .when_undefined(o => o.data = o.data)
                .map<string?>("info", o => o.info, (o, v) => o.info = v)
                    .when_undefined(o => o.info = o.info)
                .map<string?>("lib", o => o.lib, (o, v) => o.lib = v)
                    .when_undefined(o => o.lib = o.lib)
                .map<string?>("canonlib", o => o.canonlib, (o, v) => o.canonlib = v)
                    .when_undefined(o => o.canonlib = o.canonlib)
                .map<string?>("man", o => o.man, (o, v) => o.man = v)
                    .when_undefined(o => o.man = o.man)
                .map<string?>("libexec", o => o.libexec, (o, v) => o.libexec = v)
                    .when_undefined(o => o.libexec = o.libexec)
                .map<string?>("locale", o => o.locale, (o, v) => o.locale = v)
                    .when_undefined(o => o.locale = o.locale)
                .map<string?>("localState", o => o.local_state, (o, v) => o.local_state = v)
                    .when_undefined(o => o.local_state = o.local_state)
                .map<string?>("sbin", o => o.sbin, (o, v) => o.sbin = v)
                    .when_undefined(o => o.sbin = o.sbin)
                .map<string?>("sharedState", o => o.shared_state, (o, v) => o.shared_state = v)
                    .when_undefined(o => o.shared_state = o.shared_state)
                .map<string?>("sysConfig", o => o.sys_config, (o, v) => o.sys_config = v)
                    .when_undefined(o => o.sys_config = o.sys_config)
                .map<string?>("tags", o => o.tags, (o, v) => o.tags = v)
                    .when_undefined(o => o.tags = o.tags)
                .set_constructor(() => new Paths.defaults())
                .build();
        }
    }

}