using Invercargill;
using Invercargill.Convert;
namespace Usm {

    public enum ResourceType {
        RESOURCE,
        BINARY,
        SUPER_BINARY,
        LIBRARY,
        LIBRARY_EXECUTABLE,
        LIBRARY_RESOURCE,
        INFO_PAGE,
        MANUAL_PAGE,
        LOCALE,
        APPLICATION,
        INCLUDE,
        PKG_CONFIG,
        VALA_API;

        public string to_string() {
            switch (this) {
                case ResourceType.RESOURCE:
                    return "res";
                case ResourceType.BINARY:
                    return "bin";
                case ResourceType.SUPER_BINARY:
                    return "sbin";
                case ResourceType.LIBRARY:
                    return "lib";
                case ResourceType.LIBRARY_EXECUTABLE:
                    return "libexec";
                case ResourceType.LIBRARY_RESOURCE:
                    return "libres";
                case ResourceType.INFO_PAGE:
                    return "info";
                case ResourceType.MANUAL_PAGE:
                    return "man";
                case ResourceType.LOCALE:
                    return "locale";
                case ResourceType.APPLICATION:
                    return "app";
                case ResourceType.INCLUDE:
                    return "inc";
                case ResourceType.PKG_CONFIG:
                    return "pc";
                case ResourceType.VALA_API:
                    return "vapi";
                default:
                    assert_not_reached();
            }
        }

        public static ResourceType from_string(string str) throws ManifestError {
            switch (str) {
                case "res":
                    return ResourceType.RESOURCE;
                case "bin":
                    return ResourceType.BINARY;
                case "sbin":
                    return ResourceType.SUPER_BINARY;
                case "lib":
                    return ResourceType.LIBRARY;
                case "libexec":
                    return ResourceType.LIBRARY_EXECUTABLE;
                case "libres":
                    return ResourceType.LIBRARY_RESOURCE;
                case "info":
                    return ResourceType.INFO_PAGE;
                case "man":
                    return ResourceType.MANUAL_PAGE;
                case "locale":
                    return ResourceType.LOCALE;
                case "app":
                    return ResourceType.APPLICATION;
                case "inc":
                    return ResourceType.INCLUDE;
                case "pc":
                    return ResourceType.PKG_CONFIG;
                case "vapi":
                    return ResourceType.VALA_API;
                default:
                    throw new ManifestError.INVALID_RESOURCE_TYPE(@"Unknown resource type \"$str\".");
            }
        }
    }

    public class ResourceRef : Hashable, Equatable<ResourceRef> {
        public string resource { get; set; }
        public ResourceType resource_type { get; set; }

        public ResourceRef(string str) throws ManifestError {
            var parts = str.split(":", 2);
            resource_type = ResourceType.from_string(parts[0]);
            resource = parts[1];
        }
        
        public uint hash_code() {
            return to_string().hash();
        }
        public bool equals(ResourceRef other) {
            return this == other || (this.resource == other.resource && this.resource_type == other.resource_type);
        }
        public string to_string() {
            return @"$resource_type:$resource";
        }
        
        public bool is_satisfied() {
            switch (resource_type) {
                case ResourceType.RESOURCE:
                    return check_res();
                case ResourceType.BINARY:
                    return check_bin();
                case ResourceType.SUPER_BINARY:
                    return check_sbin();
                case ResourceType.LIBRARY:
                    return check_lib();
                case ResourceType.LIBRARY_EXECUTABLE:
                    return check_libexec();
                case ResourceType.LIBRARY_RESOURCE:
                    return check_libres();
                case ResourceType.INFO_PAGE:
                    return check_info();
                case ResourceType.MANUAL_PAGE:
                    return check_man();
                case ResourceType.LOCALE:
                    return check_locale();
                case ResourceType.APPLICATION:
                    return check_app();
                case ResourceType.INCLUDE:
                    return check_inc();
                case ResourceType.PKG_CONFIG:
                    return check_pc();
                case ResourceType.VALA_API:
                    return check_vapi();
                default:
                    assert_not_reached();
            }
        }

        private bool check_lib() {
            try {
                var proc = new Subprocess.newv(new string[] { "ldconfig", "-p" }, SubprocessFlags.STDOUT_PIPE);
                var pipe = new DataInputStream(proc.get_stdout_pipe());
                string line = null;
                while((line = pipe.read_line()) != null) {
                    if(line.has_prefix("\t")) {
                        var name = line.substring(1).split(" ", 2)[0];
                        if(resource == name) {
                            return true;
                        }
                    }
                }
                proc.wait_check();
            }
            catch(Error e) {
                warning(@"Error checking for resource $this: $(e.message)");
            }
            return false;
        }

        private bool check_bin() {
            var paths = Environment.get_variable("PATH").split(":");
            foreach (var path in paths) {
                var file = File.new_build_filename(path, resource);
                if(file.query_exists()) {
                    return true;
                }
            }
            return false;
        }

        private bool check_res() {
            var file = File.new_build_filename("/", resource);
            return file.query_exists();
        }

        private bool check_libres() {
            var paths = new string[] { "/usr/lib", "/usr/lib64", "/lib", "/lib64" };
            foreach (var path in paths) {
                var file = File.new_build_filename(path, resource);
                if(file.query_exists()) {
                    return true;
                }
            }
            return false;
        }

        private bool check_app() {
            var file = File.new_build_filename("/usr/share/applications", resource);
            return file.query_exists();
        }

        private bool check_inc() {
            var file = File.new_build_filename("/usr/include", resource);
            return file.query_exists();
        }

        private bool check_sbin() {
            var paths = new string[] { "/usr/sbin", "/sbin" };
            foreach (var path in paths) {
                var file = File.new_build_filename(path, resource);
                if(file.query_exists()) {
                    return true;
                }
            }
            return false;
        }

        private bool check_libexec() {
            var file = File.new_build_filename("/usr/libexec", resource);
            return file.query_exists();
        }

        private bool check_info() {
            var file = File.new_build_filename("/usr/share/info", resource);
            return file.query_exists();
        }

        private bool check_man() {
            var file = File.new_build_filename("/usr/share/man", resource);
            return file.query_exists();
        }

        private bool check_locale() {
            var file = File.new_build_filename("/usr/share/locale", resource);
            return file.query_exists();
        }

        private bool check_vapi() {
            var paths = new string[] { "/usr/share/vala/vapi", "/usr/share/vala-0.56/vapi" };
            foreach (var path in paths) {
                var file = File.new_build_filename(path, resource);
                if(file.query_exists()) {
                    return true;
                }
            }
            return false;
        }

        private bool check_pc() {
            var paths = ate(new string[] { "/usr/lib/pkgconfig", "/usr/lib64/pkgconfig", "/usr/share/pkgconfig" });
            var env = Environment.get_variable("PKG_CONFIG_PATH");
            if(env != null) {
                paths = paths.concat(ate(env.split(":")));
            }

            foreach (var path in paths) {
                var file = File.new_build_filename(path, resource);
                if(file.query_exists()) {
                    return true;
                }
            }
            return false;
        }
    }

}