require "db/mongo/models/mongo_model"
require "db/mongo/models/model_with_provider"
require "db/validators/deploy_env/run_list"
require "providers/static"

module Devops
  module Model
    class Server < MongoModel

      include ModelWithProvider

      module OperationType
        # we store strings in mongo, so it's better not to use symbols
        CREATION = 'creation'
        DEPLOY = 'deploy'
        RESERVE = 'reserve'
        UNRESERVE = 'unreserve'
        PAUSE = 'pause'
        UNPAUSE = 'unpause'

        def self.supported_type?(value)
          return false unless value.is_a?(String)
          [CREATION, DEPLOY, RESERVE, UNRESERVE, PAUSE, UNPAUSE].include?(value)
        end
      end

      attr_accessor :chef_node_name, :id, :remote_user, :project, :deploy_env, :private_ip, :public_ip, :created_at, :without_bootstrap, :created_by, :reserved_by, :stack, :run_list
      attr_accessor :key, :last_operation

      types :id => {:type => String, :empty => false},
            :provider => {:type => String, :empty => false},
            :remote_user => {:type => String, :empty => false},
            :project => {:type => String, :empty => false},
            :deploy_env => {:type => String, :empty => false},
            :private_ip => {:type => String, :empty => false},
            :public_ip => {:type => String, :empty => true, :nil => true},
            :key => {:type => String, :empty => false},
            :created_by => {:type => String, :empty => false},
            :chef_node_name => {:type => String, :empty => true},
            :reserved_by => {:type => String, :empty => true},
            :stack => {:type => String, :nil => true},
            :run_list => {:type => Array, :value_type => String, :empty => true, :nil => false}

      set_validators  ::Validators::DeployEnv::RunList

      def self.fields
        ["chef_node_name", "project", "deploy_env", "provider", "remote_user", "private_ip", "public_ip", "created_at", "created_by", "key", "reserved_by", "run_list", "stack",
          "last_operation"]
      end

      def initialize s={}
        self.set_provider(s)
        self.chef_node_name = s["chef_node_name"]
        self.id = s["_id"] || s['id']
        self.remote_user = s["remote_user"]
        self.project = s["project"]
        self.deploy_env = s["deploy_env"]
        self.public_ip = s["public_ip"]
        self.private_ip = s["private_ip"]
        self.created_at = s["created_at"]
        self.created_by = s["created_by"]
        self.key = s["key"]
        self.reserved_by = s["reserved_by"]
        self.stack = s["stack"]
        self.run_list = s["run_list"] || []
        self.last_operation = s["last_operation"]
        self
      end

      def validate!
        # remove it after updating from .types to validators
        validate_fields_types
        super
        true
      end

      def to_hash_without_id
        {
          "chef_node_name" => self.chef_node_name,
          "remote_user" => self.remote_user,
          "project" => self.project,
          "deploy_env" => self.deploy_env,
          "private_ip" => self.private_ip,
          "public_ip" => self.public_ip,
          "created_at" => self.created_at,
          "created_by" => self.created_by,
          "key" => self.key,
          "reserved_by" => self.reserved_by,
          "stack" => stack,
          "run_list" => self.run_list,
          "last_operation" => self.last_operation
        }.merge(provider_hash).delete_if { |k,v| v.nil? }
      end

      def self.build_from_bson s
        Server.new(s)
      end

      def info
        str = "Instance Name: #{self.chef_node_name}\n"
        str << "Instance ID: #{self.id}\n"
        str << "Private IP: #{self.private_ip}\n"
        str << "Public IP: #{self.public_ip}\n" unless self.public_ip.nil?
        str << "Remote user: #{self.remote_user}\n"
        str << "Project: #{self.project} - #{self.deploy_env}\n"
        str << "Created by: #{self.created_by}"
        str
      end

      def static?
        self.provider == Provider::Static::PROVIDER
      end

      def set_last_operation(operation_type, user)
        raise ArgumentError unless OperationType.supported_type?(operation_type)
        self.last_operation = {
          'type' => operation_type,
          'date' => Time.now,
          'user' => user
        }
      end

    end
  end
end